@nuxt/ui 4.3.0 → 4.5.0

package/dist/runtime/components/prose/callout/Warning.d.vue.ts

@@ -1,8 +1,8 @@
-declare var __VLS_7: {
+declare var __VLS_8: {
     mdcUnwrap: string;
 };
 type __VLS_Slots = {} & {
-    default?: (props: typeof __VLS_7) => any;
+    default?: (props: typeof __VLS_8) => any;
 };
 declare const __VLS_base: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;

package/dist/runtime/components/prose/callout/Warning.vue.d.ts

@@ -1,8 +1,8 @@
-declare var __VLS_7: {
+declare var __VLS_8: {
     mdcUnwrap: string;
 };
 type __VLS_Slots = {} & {
-    default?: (props: typeof __VLS_7) => any;
+    default?: (props: typeof __VLS_8) => any;
 };
 declare const __VLS_base: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;

package/dist/runtime/composables/defineShortcuts.js

@@ -95,7 +95,10 @@ export function defineShortcuts(config, options = {}) {
       if (e.ctrlKey !== shortcut.ctrlKey) {
         continue;
       }
-      if ((alphabetKey || shiftableKey) && e.shiftKey !== shortcut.shiftKey) {
+      if (e.altKey !== shortcut.altKey) {
+        continue;
+      }
+      if ((alphabetKey || shiftableKey || shortcut.shiftKey || e.shiftKey && (e.metaKey || e.ctrlKey)) && e.shiftKey !== shortcut.shiftKey) {
         continue;
       }
       if (shortcut.enabled) {

package/dist/runtime/composables/internal/useFilter.d.ts

@@ -0,0 +1,9 @@
+export declare function useFilter(): {
+    score: (value: string, searchTerm: string) => number | null;
+    scoreItem: (item: any, searchTerm: string, fields: string[]) => number | null;
+    filter: <T>(items: T[], searchTerm: string, fields: string[]) => T[];
+    filterGroups: <T>(groups: T[][], searchTerm: string, options: {
+        fields: string[];
+        isStructural?: (item: T) => boolean;
+    }) => T[][];
+};

package/dist/runtime/composables/internal/useFilter.js

@@ -0,0 +1,60 @@
+import { useFilter as useRekaFilter } from "reka-ui";
+import { get } from "../../utils/index.js";
+export function useFilter() {
+  const { contains, startsWith } = useRekaFilter({ sensitivity: "base" });
+  function score(value, searchTerm) {
+    if (!contains(value, searchTerm)) return null;
+    if (contains(searchTerm, value)) return 0;
+    if (startsWith(value, searchTerm)) return 1;
+    return 2;
+  }
+  function scoreItem(item, searchTerm, fields) {
+    if (typeof item !== "object" || item === null) {
+      return score(String(item), searchTerm);
+    }
+    let bestScore = null;
+    for (const field of fields) {
+      const value = get(item, field);
+      if (value == null) continue;
+      const values = Array.isArray(value) ? value.map(String) : [String(value)];
+      for (const v of values) {
+        const s = score(v, searchTerm);
+        if (s !== null && (bestScore === null || s < bestScore)) bestScore = s;
+        if (bestScore === 0) return 0;
+      }
+    }
+    return bestScore;
+  }
+  function filter(items, searchTerm, fields) {
+    if (!searchTerm) return items;
+    const scored = [];
+    for (const item of items) {
+      const s = scoreItem(item, searchTerm, fields);
+      if (s !== null) {
+        scored.push({ item, score: s });
+      }
+    }
+    scored.sort((a, b) => a.score - b.score);
+    return scored.map(({ item }) => item);
+  }
+  function filterGroups(groups, searchTerm, options) {
+    if (!searchTerm) return groups;
+    return groups.map((group) => {
+      const result = [];
+      for (const item of group) {
+        if (item === void 0 || item === null) continue;
+        if (options.isStructural?.(item)) {
+          result.push({ item, score: -1 });
+          continue;
+        }
+        const s = scoreItem(item, searchTerm, options.fields);
+        if (s !== null) {
+          result.push({ item, score: s });
+        }
+      }
+      result.sort((a, b) => a.score - b.score);
+      return result.map(({ item }) => item);
+    }).filter((group) => group.some((item) => !options.isStructural?.(item)));
+  }
+  return { score, scoreItem, filter, filterGroups };
+}

package/dist/runtime/composables/useAvatarGroup.d.ts

@@ -6,5 +6,5 @@ export declare const avatarGroupInjectionKey: InjectionKey<ComputedRef<{
 export declare function useAvatarGroup(props: {
     size: AvatarGroupProps['size'];
 }): {
-    size: ComputedRef<"md" | "3xs" | "2xs" | "xs" | "sm" | "lg" | "xl" | "2xl" | "3xl" | undefined>;
+    size: ComputedRef<"2xl" | "3xs" | "2xs" | "xs" | "sm" | "md" | "lg" | "xl" | "3xl" | undefined>;
 };

package/dist/runtime/composables/useComponentUI.d.ts

@@ -0,0 +1,33 @@
+import type { ComputedRef } from 'vue';
+import type { ClassValue } from 'tailwind-variants';
+import type { TVConfig } from '../types/tv';
+import type * as ui from '#build/ui';
+type UIConfig = TVConfig<typeof ui>;
+type ExtractUISlots<C> = C extends {
+    slots?: infer S;
+} ? NonNullable<S> : never;
+type UIConfigSlots<T extends keyof UIConfig> = 'slots' extends keyof NonNullable<UIConfig[T]> ? ExtractUISlots<NonNullable<UIConfig[T]>> : {
+    base?: ClassValue;
+};
+type ThemeSlotOverrides<T> = T extends {
+    slots: infer S extends Record<string, any>;
+} ? {
+    [K in keyof S]?: ClassValue;
+} : {
+    [K in keyof T]?: T[K] extends Record<string, any> ? ThemeSlotOverrides<T[K]> : ClassValue;
+};
+export type ThemeUI = {
+    [K in keyof typeof ui]?: ThemeSlotOverrides<(typeof ui)[K]>;
+};
+export type ThemeRootContext = {
+    ui: ComputedRef<ThemeUI>;
+};
+declare const provideThemeContext: (contextValue: ThemeRootContext) => ThemeRootContext;
+export { provideThemeContext };
+type ComponentUIProps<T extends keyof UIConfig> = {
+    ui?: UIConfigSlots<T>;
+};
+export declare function useComponentUI<T extends keyof UIConfig>(name: T, props: ComponentUIProps<T>): ComputedRef<UIConfigSlots<T>>;
+export declare function useComponentUI(name: string, props: {
+    ui?: any;
+}): ComputedRef<any>;

package/dist/runtime/composables/useComponentUI.js

@@ -0,0 +1,13 @@
+import { computed } from "vue";
+import defu from "defu";
+import { createContext } from "reka-ui";
+import { get } from "../utils/index.js";
+const [injectThemeContext, provideThemeContext] = createContext("UTheme", "RootContext");
+export { provideThemeContext };
+export function useComponentUI(name, props) {
+  const { ui } = injectThemeContext({ ui: computed(() => ({})) });
+  return computed(() => {
+    const themeOverrides = get(ui.value, name) || {};
+    return defu(props.ui ?? {}, themeOverrides);
+  });
+}

package/dist/runtime/composables/useEditorMenu.d.ts

@@ -24,11 +24,21 @@ export interface EditorMenuOptions<T = any> {
      * Function to filter items based on query
      */
     filter?: (items: T[], query: string) => T[];
+    /**
+     * Whether to ignore the default filtering.
+     * When `true`, items will not be filtered which is useful for custom filtering (useAsyncData, useFetch, etc.).
+     * @defaultValue false
+     */
+    ignoreFilter?: boolean;
     /**
      * Maximum number of items to display
      * @defaultValue 42
      */
     limit?: number;
+    /**
+     * Ref to sync the current search term with
+     */
+    searchTerm?: Ref<string>;
     /**
      * Function to execute when an item is selected
      */
@@ -58,7 +68,8 @@ export interface EditorMenuOptions<T = any> {
     ui: ComputedRef<any>;
 }
 export declare function useEditorMenu<T = any>(options: EditorMenuOptions<T>): {
-    plugin: import("prosemirror-state").Plugin<any>;
+    plugin: import("@tiptap/pm/state").Plugin<any>;
     destroy: () => void;
     filteredItems: Ref<T[], T[]>;
+    searchTerm: Ref<string, string>;
 };

package/dist/runtime/composables/useEditorMenu.js

@@ -1,6 +1,6 @@
-import { ref, h, computed, unref } from "vue";
+import { ref, h, computed, unref, watch } from "vue";
 import { defu } from "defu";
-import { useFilter } from "reka-ui";
+import { useFilter } from "./internal/useFilter.js";
 import { computePosition } from "@floating-ui/dom";
 import { VueRenderer } from "@tiptap/vue-3";
 import Suggestion from "@tiptap/suggestion";
@@ -11,6 +11,7 @@ export function useEditorMenu(options) {
   const filteredItems = ref([]);
   const selectedIndex = ref(0);
   const menuState = ref("closed");
+  const searchTerm = options.searchTerm ?? ref("");
   let renderer = null;
   let element = null;
   let handleMouseDown = null;
@@ -21,7 +22,8 @@ export function useEditorMenu(options) {
   let triggerClientRect = null;
   let handleHover = null;
   let scrollHandler = null;
-  const { contains } = useFilter({ sensitivity: "base" });
+  let stopItemsWatch = null;
+  const { score } = useFilter();
   const cleanupMenu = () => {
     if (menuState.value === "closed") return;
     menuState.value = "closed";
@@ -53,17 +55,31 @@ export function useEditorMenu(options) {
   const filterFields = options.filterFields ?? ["label"];
   const defaultFilter = (items2, query) => {
     if (!query) return items2;
-    return items2.filter((item) => {
-      return filterFields.some((field) => {
+    const scored = [];
+    for (const item of items2) {
+      let bestScore = null;
+      for (const field of filterFields) {
         const value = get(item, field);
-        if (value === void 0 || value === null) return false;
-        const stringValue = Array.isArray(value) ? value.join(" ") : String(value);
-        return contains(stringValue, query) || contains(stringValue.replace(/[\s_-]/g, ""), query);
-      });
-    });
+        if (value == null) continue;
+        const values = Array.isArray(value) ? value.map(String) : [String(value)];
+        for (const v of values) {
+          const normalized = v.replace(/[\s_-]/g, "");
+          const s = Math.min(score(v, query) ?? 3, score(normalized, query) ?? 3);
+          if (bestScore === null || s < bestScore) bestScore = s;
+          if (bestScore === 0) break;
+        }
+        if (bestScore === 0) break;
+      }
+      if (bestScore !== null && bestScore < 3) {
+        scored.push({ item, score: bestScore });
+      }
+    }
+    scored.sort((a, b) => a.score - b.score);
+    return scored.map(({ item }) => item);
   };
   const filter = options.filter || defaultFilter;
   const limit = options.limit ?? 42;
+  const pluginKeyInstance = typeof options.pluginKey === "string" ? new PluginKey(options.pluginKey) : options.pluginKey;
   const groups = computed(() => {
     const items2 = unref(options.items);
     return items2?.length ? isArrayOfArray(items2) ? items2 : [items2] : [];
@@ -71,7 +87,14 @@ export function useEditorMenu(options) {
   const items = computed(() => groups.value.flatMap((group) => group));
   const filteredGroups = computed(() => {
     if (!filteredItems.value.length) return [];
-    return groups.value.map((group) => group.filter((item) => filteredItems.value.includes(item))).filter((group) => group.length > 0);
+    if (options.ignoreFilter) {
+      return [filteredItems.value];
+    }
+    return groups.value.map((group) => {
+      const filtered = group.filter((item) => filteredItems.value.includes(item));
+      filtered.sort((a, b) => filteredItems.value.indexOf(a) - filteredItems.value.indexOf(b));
+      return filtered;
+    }).filter((group) => group.length > 0);
   });
   const selectableItems = computed(() => {
     return filteredItems.value.filter((item) => {
@@ -90,25 +113,124 @@ export function useEditorMenu(options) {
     inline: false
   });
   const middleware = buildFloatingUIMiddleware(floatingUIOptions);
-  const updatePosition = (element2) => {
+  const updatePosition = (el) => {
     if (!triggerClientRect) return;
     const rect = triggerClientRect();
     if (!rect) return;
     const virtualElement = {
       getBoundingClientRect: () => rect
     };
-    computePosition(virtualElement, element2, {
+    computePosition(virtualElement, el, {
       placement: floatingUIOptions.placement,
       strategy: floatingUIOptions.strategy,
       middleware
     }).then(({ x, y, strategy }) => {
-      element2.style.width = "max-content";
-      element2.style.position = strategy;
-      element2.style.top = "0";
-      element2.style.left = "0";
-      element2.style.transform = `translate(${Math.round(x)}px, ${Math.round(y)}px)`;
+      el.style.width = "max-content";
+      el.style.position = strategy;
+      el.style.top = "0";
+      el.style.left = "0";
+      el.style.transform = `translate(${Math.round(x)}px, ${Math.round(y)}px)`;
+    });
+  };
+  const showMenu = () => {
+    menuState.value = "open";
+    if (!globalKeyHandler) {
+      globalKeyHandler = (e) => {
+        if (keyDownHandler) {
+          const handled = keyDownHandler({ event: e });
+          if (handled) {
+            e.preventDefault();
+            e.stopPropagation();
+          }
+        }
+      };
+      document.addEventListener("keydown", globalKeyHandler, true);
+    }
+    if (!blurHandler) {
+      blurHandler = () => {
+        setTimeout(() => {
+          if (menuState.value === "open") {
+            const tr = options.editor.view.state.tr.setMeta(pluginKeyInstance, { exit: true });
+            options.editor.view.dispatch(tr);
+          }
+        }, 0);
+      };
+      options.editor.view.dom.addEventListener("blur", blurHandler);
+    }
+    if (!scrollHandler) {
+      scrollHandler = () => {
+        if (element) {
+          updatePosition(element);
+        }
+      };
+      window.addEventListener("scroll", scrollHandler, true);
+    }
+    handleHover = (index) => {
+      selectedIndex.value = index;
+      if (renderer) {
+        renderer.updateProps({
+          groups: filteredGroups.value,
+          selectedIndex: index,
+          onSelect: commandFn,
+          onHover: handleHover,
+          state: menuState.value
+        });
+      }
+    };
+    renderer = new VueRenderer(MenuComponent, {
+      props: {
+        groups: filteredGroups.value,
+        selectedIndex: selectedIndex.value,
+        onSelect: commandFn,
+        onHover: handleHover,
+        state: menuState.value
+      },
+      editor: options.editor
     });
+    element = document.createElement("div");
+    element.style.position = floatingUIOptions.strategy;
+    element.style.zIndex = "50";
+    handleMouseDown = (e) => {
+      e.preventDefault();
+    };
+    element.addEventListener("mousedown", handleMouseDown);
+    const appendToElement = typeof options.appendTo === "function" ? options.appendTo() : options.appendTo;
+    (appendToElement ?? options.editor.view.dom.parentElement)?.appendChild(element);
+    if (renderer.element) {
+      element.appendChild(renderer.element);
+    }
+    updatePosition(element);
   };
+  if (options.ignoreFilter) {
+    stopItemsWatch = watch(() => unref(options.items), (newItems) => {
+      if (!triggerClientRect) return;
+      const normalizedItems = newItems?.length ? isArrayOfArray(newItems) ? newItems.flat() : newItems : [];
+      filteredItems.value = normalizedItems.slice(0, limit);
+      if (!filteredItems.value.length) {
+        cleanupMenu();
+        return;
+      }
+      if (selectedIndex.value >= selectableItems.value.length) {
+        selectedIndex.value = Math.max(0, selectableItems.value.length - 1);
+      }
+      if (menuState.value === "closed" && filteredItems.value.length) {
+        showMenu();
+        return;
+      }
+      if (renderer) {
+        renderer.updateProps({
+          groups: filteredGroups.value,
+          selectedIndex: selectedIndex.value,
+          onSelect: commandFn,
+          onHover: handleHover,
+          state: menuState.value
+        });
+      }
+      if (element) {
+        updatePosition(element);
+      }
+    }, { deep: true, flush: "sync" });
+  }
   const MenuComponent = {
     props: {
       groups: { type: Array, required: true },
@@ -188,13 +310,16 @@ export function useEditorMenu(options) {
       };
     }
   };
-  const pluginKeyInstance = typeof options.pluginKey === "string" ? new PluginKey(options.pluginKey) : options.pluginKey;
   const plugin = Suggestion({
     pluginKey: pluginKeyInstance,
     editor: options.editor,
     char: options.char,
-    items: ({ query }) => {
-      const filtered = filter(items.value, query);
+    items: ({ query: q }) => {
+      searchTerm.value = q;
+      if (options.ignoreFilter) {
+        return items.value.slice(0, limit);
+      }
+      const filtered = filter(items.value, q);
       return filtered.slice(0, limit);
     },
     command: ({ editor, range, props }) => {
@@ -243,77 +368,17 @@ export function useEditorMenu(options) {
       };
       const handlers = {
         onStart: (suggestionProps) => {
-          filteredItems.value = suggestionProps.items;
+          filteredItems.value = options.ignoreFilter ? items.value.slice(0, limit) : suggestionProps.items;
           selectedIndex.value = 0;
           commandFn = (item) => suggestionProps.command(item);
           triggerClientRect = suggestionProps.clientRect;
           if (!filteredItems.value.length) {
             return;
           }
-          menuState.value = "open";
-          globalKeyHandler = (e) => {
-            if (keyDownHandler) {
-              const handled = keyDownHandler({ event: e });
-              if (handled) {
-                e.preventDefault();
-                e.stopPropagation();
-              }
-            }
-          };
-          document.addEventListener("keydown", globalKeyHandler, true);
-          blurHandler = () => {
-            setTimeout(() => {
-              if (menuState.value === "open") {
-                const tr = suggestionProps.editor.view.state.tr.setMeta(pluginKeyInstance, { exit: true });
-                suggestionProps.editor.view.dispatch(tr);
-              }
-            }, 0);
-          };
-          suggestionProps.editor.view.dom.addEventListener("blur", blurHandler);
-          scrollHandler = () => {
-            if (element) {
-              updatePosition(element);
-            }
-          };
-          window.addEventListener("scroll", scrollHandler, true);
-          handleHover = (index) => {
-            selectedIndex.value = index;
-            if (renderer) {
-              renderer.updateProps({
-                groups: filteredGroups.value,
-                selectedIndex: index,
-                onSelect: commandFn,
-                onHover: handleHover,
-                state: menuState.value
-              });
-            }
-          };
-          renderer = new VueRenderer(MenuComponent, {
-            props: {
-              groups: filteredGroups.value,
-              selectedIndex: selectedIndex.value,
-              onSelect: commandFn,
-              onHover: handleHover,
-              state: menuState.value
-            },
-            editor: suggestionProps.editor
-          });
-          element = document.createElement("div");
-          element.style.position = floatingUIOptions.strategy;
-          element.style.zIndex = "50";
-          handleMouseDown = (e) => {
-            e.preventDefault();
-          };
-          element.addEventListener("mousedown", handleMouseDown);
-          const appendToElement = typeof options.appendTo === "function" ? options.appendTo() : options.appendTo;
-          (appendToElement ?? suggestionProps.editor.view.dom.parentElement)?.appendChild(element);
-          if (renderer.element) {
-            element.appendChild(renderer.element);
-          }
-          updatePosition(element);
+          showMenu();
         },
         onUpdate: (suggestionProps) => {
-          filteredItems.value = suggestionProps.items;
+          filteredItems.value = options.ignoreFilter ? items.value.slice(0, limit) : suggestionProps.items;
           commandFn = (item) => suggestionProps.command(item);
           if (selectedIndex.value >= selectableItems.value.length) {
             selectedIndex.value = Math.max(0, selectableItems.value.length - 1);
@@ -323,80 +388,13 @@ export function useEditorMenu(options) {
             return;
           }
           if (!renderer) {
-            menuState.value = "open";
-            if (!globalKeyHandler) {
-              globalKeyHandler = (e) => {
-                if (keyDownHandler) {
-                  const handled = keyDownHandler({ event: e });
-                  if (handled) {
-                    e.preventDefault();
-                    e.stopPropagation();
-                  }
-                }
-              };
-              document.addEventListener("keydown", globalKeyHandler, true);
-            }
-            if (!blurHandler) {
-              blurHandler = () => {
-                setTimeout(() => {
-                  if (menuState.value === "open") {
-                    const tr = suggestionProps.editor.view.state.tr.setMeta(pluginKeyInstance, { exit: true });
-                    suggestionProps.editor.view.dispatch(tr);
-                  }
-                }, 0);
-              };
-              suggestionProps.editor.view.dom.addEventListener("blur", blurHandler);
-            }
-            if (!scrollHandler) {
-              scrollHandler = () => {
-                if (element) {
-                  updatePosition(element);
-                }
-              };
-              window.addEventListener("scroll", scrollHandler, true);
-            }
-            handleHover = (index) => {
-              selectedIndex.value = index;
-              if (renderer) {
-                renderer.updateProps({
-                  groups: filteredGroups.value,
-                  selectedIndex: index,
-                  onSelect: commandFn,
-                  onHover: handleHover,
-                  state: menuState.value
-                });
-              }
-            };
-            renderer = new VueRenderer(MenuComponent, {
-              props: {
-                groups: filteredGroups.value,
-                selectedIndex: selectedIndex.value,
-                onSelect: commandFn,
-                onHover: handleHover,
-                state: menuState.value
-              },
-              editor: suggestionProps.editor
-            });
-            element = document.createElement("div");
-            element.style.position = floatingUIOptions.strategy;
-            element.style.zIndex = "50";
-            handleMouseDown = (e) => {
-              e.preventDefault();
-            };
-            element.addEventListener("mousedown", handleMouseDown);
-            const appendToElement = typeof options.appendTo === "function" ? options.appendTo() : options.appendTo;
-            (appendToElement ?? suggestionProps.editor.view.dom.parentElement)?.appendChild(element);
-            if (renderer.element) {
-              element.appendChild(renderer.element);
-            }
+            showMenu();
           } else {
             renderer.updateProps({
               groups: filteredGroups.value,
               selectedIndex: selectedIndex.value,
               onSelect: commandFn,
-              onHover: (index) => {
-                selectedIndex.value = index;
-              },
+              onHover: handleHover,
               state: menuState.value
             });
           }
@@ -408,6 +406,7 @@ export function useEditorMenu(options) {
         onExit: () => {
           cleanupMenu();
           triggerClientRect = null;
+          searchTerm.value = "";
         }
       };
       return handlers;
@@ -439,10 +438,15 @@ export function useEditorMenu(options) {
       element.remove();
       element = null;
     }
+    if (stopItemsWatch) {
+      stopItemsWatch();
+      stopItemsWatch = null;
+    }
   };
   return {
     plugin,
     destroy,
-    filteredItems
+    filteredItems,
+    searchTerm
   };
 }

package/dist/runtime/composables/useFieldGroup.d.ts

@@ -10,6 +10,6 @@ type Props<T> = {
 };
 export declare function useFieldGroup<T>(props: Props<T>): {
     orientation: ComputedRef<"horizontal" | "vertical" | undefined>;
-    size: ComputedRef<"md" | "xs" | "sm" | "lg" | "xl" | NonNullable<GetObjectField<T, "size">> | undefined>;
+    size: ComputedRef<"xs" | "sm" | "md" | "lg" | "xl" | NonNullable<GetObjectField<T, "size">> | undefined>;
 };
 export {};

package/dist/runtime/composables/useFormField.d.ts

@@ -28,7 +28,7 @@ export declare function useFormField<T>(props?: Props<T>, opts?: {
 }): {
     id: ComputedRef<string | undefined>;
     name: ComputedRef<string | undefined>;
-    size: ComputedRef<"md" | "xs" | "sm" | "lg" | "xl" | NonNullable<GetObjectField<T, "size">> | undefined>;
+    size: ComputedRef<"xs" | "sm" | "md" | "lg" | "xl" | NonNullable<GetObjectField<T, "size">> | undefined>;
     color: ComputedRef<"error" | GetObjectField<T, "color"> | undefined>;
     highlight: ComputedRef<boolean | undefined>;
     disabled: ComputedRef<boolean | undefined>;

package/dist/runtime/composables/useOverlay.d.ts

@@ -1,5 +1,6 @@
 import type { Component } from 'vue';
 import type { ComponentProps, ComponentEmit } from 'vue-component-type-helpers';
+type CloseEventArgTypeSimple<T> = T extends (event: 'close', arg_0: infer Arg, ...args: any[]) => void ? Arg : never;
 /**
  * This is a workaround for a design limitation in TypeScript.
  *
@@ -9,7 +10,7 @@ import type { ComponentProps, ComponentEmit } from 'vue-component-type-helpers';
  *
  * @see https://github.com/microsoft/TypeScript/issues/32164
  */
-type CloseEventArgType<T> = T extends {
+type CloseEventArgTypeComplex<T> = T extends {
     (event: 'close', arg_0: infer Arg, ...args: any[]): void;
     (...args: any[]): void;
     (...args: any[]): void;
@@ -28,6 +29,7 @@ type CloseEventArgType<T> = T extends {
     (...args: any[]): void;
     (...args: any[]): void;
 } ? Arg : never;
+type CloseEventArgType<T> = CloseEventArgTypeSimple<T> | CloseEventArgTypeComplex<T>;
 export type OverlayOptions<OverlayAttrs = Record<string, any>> = {
     defaultOpen?: boolean;
     props?: OverlayAttrs;

package/dist/runtime/composables/useToast.d.ts

@@ -5,6 +5,10 @@ export declare const toastMaxInjectionKey: InjectionKey<Ref<number | undefined>>
 export interface Toast extends Omit<ToastProps, 'defaultOpen'>, EmitsToProps<ToastEmits> {
     id: string | number;
     onClick?: (toast: Toast) => void;
+    /** @internal */
+    _duplicate?: number;
+    /** @internal */
+    _updated?: boolean;
 }
 export declare function useToast(): {
     toasts: Ref<Toast[], Toast[]>;