@eslamdevui/ui 3.3.4 → 4.0.0-beta

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

@@ -0,0 +1,91 @@
+import type { AppConfig } from '@nuxt/schema';
+import type { UseFuseOptions } from '@vueuse/integrations/useFuse';
+import theme from '#build/ui/dashboard-search';
+import type { ButtonProps, InputProps, ModalProps, CommandPaletteProps, CommandPaletteSlots, CommandPaletteGroup, CommandPaletteItem, IconProps } from '../types';
+import type { ComponentConfig } from '../types/tv';
+type DashboardSearch = ComponentConfig<typeof theme, AppConfig, 'dashboardSearch'>;
+export interface DashboardSearchProps<T extends CommandPaletteItem = CommandPaletteItem> extends /* @vue-ignore */ Pick<ModalProps, 'title' | 'description' | 'overlay' | 'transition' | 'content' | 'dismissible' | 'fullscreen' | 'modal' | 'portal'> {
+    /**
+     * The icon displayed in the input.
+     * @defaultValue appConfig.ui.icons.search
+     * @IconifyIcon
+     */
+    icon?: IconProps['name'];
+    /**
+     * The placeholder text for the input.
+     * @defaultValue t('commandPalette.placeholder')
+     */
+    placeholder?: InputProps['placeholder'];
+    /**
+     * Automatically focus the input when component is mounted.
+     * @defaultValue true
+     */
+    autofocus?: boolean;
+    /** When `true`, the loading icon will be displayed. */
+    loading?: boolean;
+    /**
+     * The icon when the `loading` prop is `true`.
+     * @defaultValue appConfig.ui.icons.loading
+     * @IconifyIcon
+     */
+    loadingIcon?: IconProps['name'];
+    /**
+     * Display a close button in the input (useful when inside a Modal for example).
+     * `{ size: 'md', color: 'neutral', variant: 'ghost' }`{lang="ts-type"}
+     * @emits 'update:open'
+     * @defaultValue true
+     */
+    close?: boolean | Partial<ButtonProps>;
+    /**
+     * The icon displayed in the close button.
+     * @defaultValue appConfig.ui.icons.close
+     * @IconifyIcon
+     */
+    closeIcon?: IconProps['name'];
+    /**
+     * Keyboard shortcut to open the search (used by [`defineShortcuts`](https://ui.nuxt.com/docs/composables/define-shortcuts))
+     * @defaultValue 'meta_k'
+     */
+    shortcut?: string;
+    groups?: CommandPaletteGroup<T>[];
+    /**
+     * Options for [useFuse](https://vueuse.org/integrations/useFuse) passed to the [CommandPalette](https://ui.nuxt.com/docs/components/command-palette).
+     * @defaultValue {}
+     */
+    fuse?: UseFuseOptions<T>;
+    /**
+     * When `true`, the theme command will be added to the groups.
+     * @defaultValue true
+     */
+    colorMode?: boolean;
+    class?: any;
+    ui?: DashboardSearch['slots'] & CommandPaletteProps<CommandPaletteGroup<CommandPaletteItem>, CommandPaletteItem>['ui'];
+}
+export type DashboardSearchSlots = CommandPaletteSlots<CommandPaletteGroup<CommandPaletteItem>, CommandPaletteItem> & {
+    content(props?: {}): any;
+};
+declare const _default: __VLS_WithSlots<import("vue").DefineComponent<DashboardSearchProps<CommandPaletteItem> & {
+    open?: boolean;
+    searchTerm?: string;
+}, {
+    commandPaletteRef: Readonly<import("vue").ShallowRef<import("vue").ShallowUnwrapRef<{}> | null>>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:open": (value: boolean) => any;
+    "update:searchTerm": (value: string) => any;
+}, string, import("vue").PublicProps, Readonly<DashboardSearchProps<CommandPaletteItem> & {
+    open?: boolean;
+    searchTerm?: string;
+}> & Readonly<{
+    "onUpdate:open"?: ((value: boolean) => any) | undefined;
+    "onUpdate:searchTerm"?: ((value: string) => any) | undefined;
+}>, {
+    close: boolean | Partial<ButtonProps>;
+    colorMode: boolean;
+    shortcut: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, DashboardSearchSlots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/DashboardSearch.vue

@@ -8,17 +8,19 @@ import { useForwardProps } from "reka-ui";
 import { defu } from "defu";
 import { reactivePick } from "@vueuse/core";
 import { useAppConfig, useColorMode, defineShortcuts, useRuntimeHook } from "#imports";
-import { useLocalePro } from "../composables/useLocalePro";
-import { transformUI, omit } from "../utils";
+import { useLocale } from "../composables/useLocale";
+import { omit, transformUI } from "../utils";
 import { tv } from "../utils/tv";
+import UCommandPalette from "./CommandPalette.vue";
+import UModal from "./Modal.vue";
 const props = defineProps({
-  icon: { type: String, required: false },
+  icon: { type: [String, Object], required: false },
   placeholder: { type: String, required: false },
   autofocus: { type: Boolean, required: false },
   loading: { type: Boolean, required: false },
-  loadingIcon: { type: String, required: false },
+  loadingIcon: { type: [String, Object], required: false },
   close: { type: [Boolean, Object], required: false, default: true },
-  closeIcon: { type: String, required: false },
+  closeIcon: { type: [String, Object], required: false },
   shortcut: { type: String, required: false, default: "meta_k" },
   groups: { type: Array, required: false },
   fuse: { type: Object, required: false },
@@ -27,65 +29,57 @@ const props = defineProps({
   ui: { type: void 0, required: false }
 });
 const slots = defineSlots();
-const open = defineModel("open", { type: Boolean, default: false });
-const searchTerm = defineModel("searchTerm", { type: String, default: "" });
+const open = defineModel("open", { type: Boolean, ...{ default: false } });
+const searchTerm = defineModel("searchTerm", { type: String, ...{ default: "" } });
 useRuntimeHook("dashboard:search:toggle", () => {
   open.value = !open.value;
 });
-const { t } = useLocalePro();
-const colorModeComposable = useColorMode();
+const { t } = useLocale();
+const colorMode = useColorMode();
 const appConfig = useAppConfig();
-const commandPaletteProps = useForwardProps(
-  reactivePick(props, "icon", "placeholder", "autofocus", "loading", "loadingIcon", "close", "closeIcon")
-);
-const proxySlots = omit(slots, ["content"]);
-const fuse = computed(
-  () => defu({}, props.fuse, {
-    fuseOptions: {}
-  })
-);
-const uiPro = computed(() => tv({
-  extend: tv(theme),
-  ...appConfig.ui?.dashboardSearch
-})());
+const commandPaletteProps = useForwardProps(reactivePick(props, "icon", "placeholder", "autofocus", "loading", "loadingIcon", "close", "closeIcon"));
+const getProxySlots = () => omit(slots, ["content"]);
+const fuse = computed(() => defu({}, props.fuse, {
+  fuseOptions: {}
+}));
+const ui = computed(() => tv({ extend: tv(theme), ...appConfig.ui?.dashboardSearch || {} })());
 const groups = computed(() => {
-  const arr = [...props.groups || []];
-  if (props.colorMode && !colorModeComposable?.forced) {
-    arr.push({
+  const groups2 = [];
+  groups2.push(...props.groups || []);
+  if (props.colorMode && !colorMode?.forced) {
+    groups2.push({
       id: "theme",
       label: t("dashboardSearch.theme"),
-      items: [
-        {
-          label: t("colorMode.system"),
-          icon: appConfig.ui.icons.system,
-          active: colorModeComposable.preference === "system",
-          onSelect: () => {
-            colorModeComposable.preference = "system";
-          }
-        },
-        {
-          label: t("colorMode.light"),
-          icon: appConfig.ui.icons.light,
-          active: colorModeComposable.preference === "light",
-          onSelect: () => {
-            colorModeComposable.preference = "light";
-          }
-        },
-        {
-          label: t("colorMode.dark"),
-          icon: appConfig.ui.icons.dark,
-          active: colorModeComposable.preference === "dark",
-          onSelect: () => {
-            colorModeComposable.preference = "dark";
-          }
+      items: [{
+        label: t("colorMode.system"),
+        icon: appConfig.ui.icons.system,
+        active: colorMode.preference === "system",
+        onSelect: () => {
+          colorMode.preference = "system";
         }
-      ]
+      }, {
+        label: t("colorMode.light"),
+        icon: appConfig.ui.icons.light,
+        active: colorMode.preference === "light",
+        onSelect: () => {
+          colorMode.preference = "light";
+        }
+      }, {
+        label: t("colorMode.dark"),
+        icon: appConfig.ui.icons.dark,
+        active: colorMode.preference === "dark",
+        onSelect: () => {
+          colorMode.preference = "dark";
+        }
+      }]
     });
   }
-  return arr;
+  return groups2;
 });
 function onSelect(item) {
-  if (item.disabled) return;
+  if (item.disabled) {
+    return;
+  }
   open.value = false;
   searchTerm.value = "";
 }
@@ -96,11 +90,18 @@ defineShortcuts({
   }
 });
 const commandPaletteRef = useTemplateRef("commandPaletteRef");
-defineExpose({ commandPaletteRef });
+defineExpose({
+  commandPaletteRef
+});
 </script>
 
 <template>
-  <UModal v-model:open="open" :class="uiPro.modal({ class: props.class })">
+  <UModal
+    v-model:open="open"
+    :title="t('dashboardSearch.title')"
+    :description="t('dashboardSearch.description')"
+    :class="ui.modal({ class: [props.ui?.modal, props.class] })"
+  >
     <template #content>
       <slot name="content">
         <UCommandPalette
@@ -109,12 +110,12 @@ defineExpose({ commandPaletteRef });
           v-bind="commandPaletteProps"
           :groups="groups"
           :fuse="fuse"
-          :ui="transformUI(uiPro, props.ui)"
+          :ui="transformUI(omit(ui, ['modal']), props.ui)"
           @update:model-value="onSelect"
           @update:open="open = $event"
         >
-          <template v-for="(_, name) in proxySlots" :key="name" #[name]="slotProps">
-            <slot :name="name" v-bind="slotProps" />
+          <template v-for="(_, name) in getProxySlots()" #[name]="slotData">
+            <slot :name="name" v-bind="slotData" />
           </template>
         </UCommandPalette>
       </slot>

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

@@ -1,31 +1,74 @@
 import type { AppConfig } from '@nuxt/schema';
-import type { ButtonProps, InputProps, CommandPaletteProps, CommandPaletteSlots, CommandPaletteGroup, CommandPaletteItem, ComponentConfig } from '../types';
 import type { UseFuseOptions } from '@vueuse/integrations/useFuse';
 import theme from '#build/ui/dashboard-search';
-export type DashboardSearch<_T extends CommandPaletteItem = CommandPaletteItem> = ComponentConfig<typeof theme, AppConfig, 'dashboardSearch'>;
-export interface DashboardSearchProps<T extends CommandPaletteItem = CommandPaletteItem> {
-    icon?: string;
+import type { ButtonProps, InputProps, ModalProps, CommandPaletteProps, CommandPaletteSlots, CommandPaletteGroup, CommandPaletteItem, IconProps } from '../types';
+import type { ComponentConfig } from '../types/tv';
+type DashboardSearch = ComponentConfig<typeof theme, AppConfig, 'dashboardSearch'>;
+export interface DashboardSearchProps<T extends CommandPaletteItem = CommandPaletteItem> extends /* @vue-ignore */ Pick<ModalProps, 'title' | 'description' | 'overlay' | 'transition' | 'content' | 'dismissible' | 'fullscreen' | 'modal' | 'portal'> {
+    /**
+     * The icon displayed in the input.
+     * @defaultValue appConfig.ui.icons.search
+     * @IconifyIcon
+     */
+    icon?: IconProps['name'];
+    /**
+     * The placeholder text for the input.
+     * @defaultValue t('commandPalette.placeholder')
+     */
     placeholder?: InputProps['placeholder'];
+    /**
+     * Automatically focus the input when component is mounted.
+     * @defaultValue true
+     */
     autofocus?: boolean;
+    /** When `true`, the loading icon will be displayed. */
     loading?: boolean;
-    loadingIcon?: string;
+    /**
+     * The icon when the `loading` prop is `true`.
+     * @defaultValue appConfig.ui.icons.loading
+     * @IconifyIcon
+     */
+    loadingIcon?: IconProps['name'];
+    /**
+     * Display a close button in the input (useful when inside a Modal for example).
+     * `{ size: 'md', color: 'neutral', variant: 'ghost' }`{lang="ts-type"}
+     * @emits 'update:open'
+     * @defaultValue true
+     */
     close?: boolean | Partial<ButtonProps>;
-    closeIcon?: string;
+    /**
+     * The icon displayed in the close button.
+     * @defaultValue appConfig.ui.icons.close
+     * @IconifyIcon
+     */
+    closeIcon?: IconProps['name'];
+    /**
+     * Keyboard shortcut to open the search (used by [`defineShortcuts`](https://ui.nuxt.com/docs/composables/define-shortcuts))
+     * @defaultValue 'meta_k'
+     */
     shortcut?: string;
     groups?: CommandPaletteGroup<T>[];
+    /**
+     * Options for [useFuse](https://vueuse.org/integrations/useFuse) passed to the [CommandPalette](https://ui.nuxt.com/docs/components/command-palette).
+     * @defaultValue {}
+     */
     fuse?: UseFuseOptions<T>;
+    /**
+     * When `true`, the theme command will be added to the groups.
+     * @defaultValue true
+     */
     colorMode?: boolean;
     class?: any;
-    ui?: DashboardSearch<T>['slots'] & CommandPaletteProps<CommandPaletteGroup<T>, T>['ui'];
+    ui?: DashboardSearch['slots'] & CommandPaletteProps<CommandPaletteGroup<CommandPaletteItem>, CommandPaletteItem>['ui'];
 }
-export type DashboardSearchSlots<T extends CommandPaletteItem = CommandPaletteItem> = CommandPaletteSlots<CommandPaletteGroup<T>, T> & {
+export type DashboardSearchSlots = CommandPaletteSlots<CommandPaletteGroup<CommandPaletteItem>, CommandPaletteItem> & {
     content(props?: {}): any;
 };
 declare const _default: __VLS_WithSlots<import("vue").DefineComponent<DashboardSearchProps<CommandPaletteItem> & {
     open?: boolean;
     searchTerm?: string;
 }, {
-    commandPaletteRef: Readonly<import("vue").ShallowRef<any>>;
+    commandPaletteRef: Readonly<import("vue").ShallowRef<import("vue").ShallowUnwrapRef<{}> | null>>;
 }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     "update:open": (value: boolean) => any;
     "update:searchTerm": (value: string) => any;
@@ -39,7 +82,7 @@ declare const _default: __VLS_WithSlots<import("vue").DefineComponent<DashboardS
     close: boolean | Partial<ButtonProps>;
     colorMode: boolean;
     shortcut: string;
-}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, DashboardSearchSlots<CommandPaletteItem>>;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, DashboardSearchSlots>;
 export default _default;
 type __VLS_WithSlots<T, S> = T & {
     new (): {

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

@@ -0,0 +1,59 @@
+import type { AppConfig } from '@nuxt/schema';
+import theme from '#build/ui/dashboard-search-button';
+import type { ButtonProps, ButtonSlots, IconProps, KbdProps, TooltipProps } from '../types';
+import type { ComponentConfig } from '../types/tv';
+type DashboardSearchButton = ComponentConfig<typeof theme, AppConfig, 'dashboardSearchButton'>;
+export interface DashboardSearchButtonProps {
+    /**
+     * The icon displayed in the button.
+     * @defaultValue appConfig.ui.icons.search
+     * @IconifyIcon
+     */
+    icon?: IconProps['name'];
+    /**
+     * The label displayed in the button.
+     * @defaultValue t('dashboardSearchButton.label')
+     */
+    label?: string;
+    /**
+     * The color of the button.
+     * @defaultValue 'neutral'
+     */
+    color?: ButtonProps['color'];
+    /**
+     * The variant of the button.
+     * Defaults to 'outline' when not collapsed, 'ghost' when collapsed.
+     */
+    variant?: ButtonProps['variant'];
+    size?: ButtonProps['size'];
+    /**
+     * Whether the button is collapsed.
+     * @defaultValue false
+     */
+    collapsed?: boolean;
+    /**
+     * Display a tooltip on the button when is collapsed with the button label.
+     * This has priority over the global `tooltip` prop.
+     */
+    tooltip?: boolean | TooltipProps;
+    /**
+     * The keyboard keys to display in the button.
+     * `{ variant: 'subtle' }`{lang="ts-type"}
+     * @defaultValue ['meta', 'k']
+     */
+    kbds?: KbdProps['value'][] | KbdProps[];
+    ui?: DashboardSearchButton['slots'] & ButtonProps['ui'];
+    class?: any;
+}
+declare const _default: __VLS_WithSlots<import("vue").DefineComponent<DashboardSearchButtonProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<DashboardSearchButtonProps> & Readonly<{}>, {
+    color: "error" | "primary" | "secondary" | "success" | "info" | "warning" | "neutral";
+    tooltip: boolean | TooltipProps;
+    kbds: KbdProps["value"][] | KbdProps[];
+    collapsed: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, ButtonSlots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/DashboardSearchButton.vue

@@ -8,13 +8,16 @@ import { useForwardProps } from "reka-ui";
 import { defu } from "defu";
 import { reactivePick, createReusableTemplate } from "@vueuse/core";
 import { useAppConfig } from "#imports";
-import UTooltip from "./Tooltip.vue";
-import { useLocalePro } from "../composables/useLocalePro";
+import { useLocale } from "../composables/useLocale";
 import { useDashboard } from "../utils/dashboard";
-import { transformUI, omit } from "../utils";
+import { omit, transformUI } from "../utils";
 import { tv } from "../utils/tv";
+import UButton from "./Button.vue";
+import UKbd from "./Kbd.vue";
+import UTooltip from "./Tooltip.vue";
+defineOptions({ inheritAttrs: false });
 const props = defineProps({
-  icon: { type: String, required: false },
+  icon: { type: [String, Object], required: false },
   label: { type: String, required: false },
   color: { type: null, required: false, default: "neutral" },
   variant: { type: null, required: false },
@@ -27,55 +30,44 @@ const props = defineProps({
 });
 const slots = defineSlots();
 const [DefineButtonTemplate, ReuseButtonTemplate] = createReusableTemplate();
-const proxySlots = omit(slots, ["trailing"]);
-const appConfig = useAppConfig();
-const { t } = useLocalePro();
-const { toggleSearch } = useDashboard();
-const labelText = computed(() => props.label || t("dashboardSearchButton.label"));
-const uiPro = computed(
-  () => tv({
-    extend: tv(theme),
-    ...appConfig.ui?.dashboardSearchButton
-  })()
-);
-const tooltipProps = toRef(
-  () => defu(
-    typeof props.tooltip === "boolean" ? {} : props.tooltip,
-    { delayDuration: 0, content: { side: "right" } }
-  )
-);
+const getProxySlots = () => omit(slots, ["trailing"]);
 const rootProps = useForwardProps(reactivePick(props, "color", "size"));
+const tooltipProps = toRef(() => defu(typeof props.tooltip === "boolean" ? {} : props.tooltip, { delayDuration: 0, content: { side: "right" } }));
+const { t } = useLocale();
+const appConfig = useAppConfig();
+const { toggleSearch } = useDashboard({ toggleSearch: () => {
+} });
+const ui = computed(() => tv({ extend: tv(theme), ...appConfig.ui?.dashboardSearchButton || {} })());
 </script>
 
 <template>
   <DefineButtonTemplate>
     <UButton
-      :icon="props.icon || appConfig.ui.icons.search"
-      :label="props.collapsed ? void 0 : labelText"
-      :variant="props.variant || (props.collapsed ? 'ghost' : 'outline')"
-      :aria-label="props.collapsed ? labelText : void 0"
-      :square="props.collapsed"
-      :class="uiPro.base({ class: [props.ui?.base, props.class] })"
-      :ui="transformUI(uiPro, props.ui)"
-      v-bind="rootProps"
+      :icon="icon || appConfig.ui.icons.search"
+      :label="label || t('dashboardSearchButton.label')"
+      :variant="variant || (collapsed ? 'ghost' : 'outline')"
+      v-bind="{
+  ...rootProps,
+  ...collapsed ? {
+    'square': true,
+    'label': void 0,
+    'aria-label': label || t('dashboardSearchButton.label')
+  } : {},
+  ...$attrs
+}"
+      :class="ui.base({ class: [props.ui?.base, props.class] })"
+      :ui="transformUI(ui, props.ui)"
       @click="toggleSearch"
     >
-      <template #default="slotProps">
-        <template v-for="(_, name) in proxySlots" :key="name">
-          <slot :name="name" v-bind="slotProps" />
-        </template>
+      <template v-for="(_, name) in getProxySlots()" #[name]="slotData">
+        <slot :name="name" v-bind="slotData" />
       </template>
 
-      <template v-if="!props.collapsed" #trailing>
-        <div :class="uiPro.trailing({ class: props.ui?.trailing })">
+      <template v-if="!collapsed" #trailing>
+        <div :class="ui.trailing({ class: props.ui?.trailing })">
           <slot name="trailing">
-            <template v-if="props.kbds?.length">
-              <UKbd
-                v-for="(kbd, index) in props.kbds"
-                :key="index"
-                variant="subtle"
-                v-bind="typeof kbd === 'string' ? { value: kbd } : kbd"
-              />
+            <template v-if="kbds?.length">
+              <UKbd v-for="(kbd, index) in kbds" :key="index" variant="subtle" v-bind="typeof kbd === 'string' ? { value: kbd } : kbd" />
             </template>
           </slot>
         </div>
@@ -83,11 +75,7 @@ const rootProps = useForwardProps(reactivePick(props, "color", "size"));
     </UButton>
   </DefineButtonTemplate>
 
-  <UTooltip
-    v-if="props.collapsed && props.tooltip"
-    :text="labelText"
-    v-bind="tooltipProps"
-  >
+  <UTooltip v-if="collapsed && tooltip" :text="label || t('dashboardSearchButton.label')" v-bind="tooltipProps">
     <ReuseButtonTemplate />
   </UTooltip>
   <ReuseButtonTemplate v-else />

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

@@ -1,14 +1,15 @@
 import type { AppConfig } from '@nuxt/schema';
-import type { ButtonProps, KbdProps, ComponentConfig, TooltipProps } from '../types';
 import theme from '#build/ui/dashboard-search-button';
-export type DashboardSearchButton = ComponentConfig<typeof theme, AppConfig, 'dashboardSearchButton'>;
+import type { ButtonProps, ButtonSlots, IconProps, KbdProps, TooltipProps } from '../types';
+import type { ComponentConfig } from '../types/tv';
+type DashboardSearchButton = ComponentConfig<typeof theme, AppConfig, 'dashboardSearchButton'>;
 export interface DashboardSearchButtonProps {
     /**
      * The icon displayed in the button.
      * @defaultValue appConfig.ui.icons.search
      * @IconifyIcon
      */
-    icon?: string;
+    icon?: IconProps['name'];
     /**
      * The label displayed in the button.
      * @defaultValue t('dashboardSearchButton.label')
@@ -44,12 +45,12 @@ export interface DashboardSearchButtonProps {
     ui?: DashboardSearchButton['slots'] & ButtonProps['ui'];
     class?: any;
 }
-declare const _default: __VLS_WithSlots<import("vue").DefineComponent<DashboardSearchButtonProps, void, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<DashboardSearchButtonProps> & Readonly<{}>, {
-    color: "error" | "info" | "primary" | "secondary" | "success" | "warning" | "neutral";
+declare const _default: __VLS_WithSlots<import("vue").DefineComponent<DashboardSearchButtonProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<DashboardSearchButtonProps> & Readonly<{}>, {
+    color: "error" | "primary" | "secondary" | "success" | "info" | "warning" | "neutral";
     tooltip: boolean | TooltipProps;
     kbds: KbdProps["value"][] | KbdProps[];
     collapsed: boolean;
-}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, __VLS_Slots>;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, ButtonSlots>;
 export default _default;
 type __VLS_WithSlots<T, S> = T & {
     new (): {

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

@@ -0,0 +1,75 @@
+import type { AppConfig } from '@nuxt/schema';
+import theme from '#build/ui/dashboard-sidebar';
+import type { UseResizableProps } from '../composables/useResizable';
+import type { ButtonProps, DrawerProps, ModalProps, SlideoverProps } from '../types';
+import type { ComponentConfig } from '../types/tv';
+type DashboardSidebar = ComponentConfig<typeof theme, AppConfig, 'dashboardSidebar'>;
+type DashboardSidebarMode = 'modal' | 'slideover' | 'drawer';
+type DashboardSidebarMenu<T> = T extends 'modal' ? ModalProps : T extends 'slideover' ? SlideoverProps : T extends 'drawer' ? DrawerProps : never;
+export interface DashboardSidebarProps<T extends DashboardSidebarMode = DashboardSidebarMode> extends Pick<UseResizableProps, 'id' | 'side' | 'minSize' | 'maxSize' | 'defaultSize' | 'resizable' | 'collapsible' | 'collapsedSize'> {
+    /**
+     * The mode of the sidebar menu.
+     * @defaultValue 'modal'
+     */
+    mode?: T;
+    /**
+     * The props for the sidebar menu component.
+     */
+    menu?: DashboardSidebarMenu<T>;
+    /**
+     * Customize the toggle button to open the sidebar.
+     * `{ color: 'neutral', variant: 'ghost' }`{lang="ts-type"}
+     * @defaultValue true
+     */
+    toggle?: boolean | Partial<ButtonProps>;
+    /**
+     * The side to render the toggle button on.
+     * @defaultValue 'left'
+     */
+    toggleSide?: 'left' | 'right';
+    class?: any;
+    ui?: DashboardSidebar['slots'];
+}
+export interface DashboardSidebarSlots {
+    'header'(props: {
+        collapsed?: boolean;
+        collapse?: (value: boolean) => void;
+    }): any;
+    'default'(props: {
+        collapsed?: boolean;
+        collapse?: (value: boolean) => void;
+    }): any;
+    'footer'(props: {
+        collapsed?: boolean;
+        collapse?: (value: boolean) => void;
+    }): any;
+    'toggle'(props: {
+        open: boolean;
+        toggle: () => void;
+    }): any;
+    'content'(props?: {}): any;
+    'resize-handle'(props: {
+        onMouseDown: (e: MouseEvent) => void;
+        onTouchStart: (e: TouchEvent) => void;
+        onDoubleClick: (e: MouseEvent) => void;
+    }): any;
+}
+declare const _default: <T extends DashboardSidebarMode>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
+        readonly "onUpdate:open"?: ((value: boolean) => any) | undefined;
+        readonly "onUpdate:collapsed"?: ((value: boolean) => any) | undefined;
+    } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>, "onUpdate:open" | "onUpdate:collapsed"> & (DashboardSidebarProps<T> & {
+        open?: boolean;
+        collapsed?: boolean;
+    }) & {}> & import("vue").PublicProps;
+    expose(exposed: import("vue").ShallowUnwrapRef<{}>): void;
+    attrs: any;
+    slots: DashboardSidebarSlots;
+    emit: ((evt: "update:open", value: boolean) => void) & ((evt: "update:collapsed", value: boolean) => void);
+}>) => import("vue").VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T as K]: T[K];
+} & {};