@nuxt/ui 3.3.3 → 4.0.0-alpha.1

package/dist/runtime/components/DashboardGroup.vue

@@ -0,0 +1,48 @@
+<script>
+import theme from "#build/ui/dashboard-group";
+</script>
+
+<script setup>
+import { ref, computed } from "vue";
+import { Primitive } from "reka-ui";
+import { useNuxtApp, useAppConfig } from "#imports";
+import { provideDashboardContext } from "../utils/dashboard";
+import { tv } from "../utils/tv";
+const props = defineProps({
+  as: { type: null, required: false },
+  class: { type: null, required: false },
+  storage: { type: String, required: false, default: "cookie" },
+  storageKey: { type: String, required: false, default: "dashboard" },
+  persistent: { type: Boolean, required: false, default: true },
+  unit: { type: String, required: false, default: "%" }
+});
+defineSlots();
+const nuxtApp = useNuxtApp();
+const appConfig = useAppConfig();
+const ui = computed(() => tv({ extend: tv(theme), ...appConfig.ui?.dashboardGroup || {} }));
+const sidebarOpen = ref(false);
+const sidebarCollapsed = ref(false);
+provideDashboardContext({
+  storage: props.storage,
+  storageKey: props.storageKey,
+  persistent: props.persistent,
+  unit: props.unit,
+  sidebarOpen,
+  toggleSidebar: () => {
+    nuxtApp.hooks.callHook("dashboard:sidebar:toggle");
+  },
+  sidebarCollapsed,
+  collapseSidebar: (collapsed) => {
+    nuxtApp.hooks.callHook("dashboard:sidebar:collapse", collapsed);
+  },
+  toggleSearch: () => {
+    nuxtApp.hooks.callHook("dashboard:search:toggle");
+  }
+});
+</script>
+
+<template>
+  <Primitive :as="as" :class="ui({ class: props.class })">
+    <slot />
+  </Primitive>
+</template>

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

@@ -0,0 +1,24 @@
+import type { UseResizableProps } from '../composables/useResizable';
+export interface DashboardGroupProps extends Pick<UseResizableProps, 'storage' | 'storageKey' | 'persistent' | 'unit'> {
+    /**
+     * The element or component this component should render as.
+     * @defaultValue 'div'
+     */
+    as?: any;
+    class?: any;
+}
+export interface DashboardGroupSlots {
+    default(props?: {}): any;
+}
+declare const _default: __VLS_WithSlots<import("vue").DefineComponent<DashboardGroupProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<DashboardGroupProps> & Readonly<{}>, {
+    storage: "cookie" | "local";
+    unit: "%" | "rem" | "px";
+    storageKey: string;
+    persistent: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, DashboardGroupSlots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/DashboardNavbar.vue

@@ -0,0 +1,72 @@
+<script>
+import theme from "#build/ui/dashboard-navbar";
+</script>
+
+<script setup>
+import { computed } from "vue";
+import { Primitive } from "reka-ui";
+import { createReusableTemplate } from "@vueuse/core";
+import { useAppConfig } from "#imports";
+import { useDashboard } from "../utils/dashboard";
+import { tv } from "../utils/tv";
+import UDashboardSidebarToggle from "./DashboardSidebarToggle.vue";
+import UIcon from "./Icon.vue";
+defineOptions({ inheritAttrs: false });
+const props = defineProps({
+  as: { type: null, required: false },
+  icon: { type: [String, Object], required: false },
+  title: { type: String, required: false },
+  toggle: { type: [Boolean, Object], required: false, default: true },
+  toggleSide: { type: String, required: false, default: "left" },
+  class: { type: null, required: false },
+  ui: { type: null, required: false }
+});
+const slots = defineSlots();
+const appConfig = useAppConfig();
+const dashboardContext = useDashboard({});
+const [DefineToggleTemplate, ReuseToggleTemplate] = createReusableTemplate();
+const ui = computed(() => tv({ extend: tv(theme), ...appConfig.ui?.dashboardNavbar || {} })());
+</script>
+
+<template>
+  <DefineToggleTemplate>
+    <slot name="toggle" v-bind="dashboardContext">
+      <UDashboardSidebarToggle
+        v-if="toggle"
+        v-bind="typeof toggle === 'object' ? toggle : {}"
+        :side="toggleSide"
+        :class="ui.toggle({ class: props.ui?.toggle, toggleSide })"
+      />
+    </slot>
+  </DefineToggleTemplate>
+
+  <Primitive :as="as" v-bind="$attrs" :class="ui.root({ class: [props.ui?.root, props.class] })">
+    <div :class="ui.left({ class: props.ui?.left })">
+      <ReuseToggleTemplate v-if="toggleSide === 'left'" />
+
+      <slot name="left" v-bind="dashboardContext">
+        <slot name="leading" v-bind="dashboardContext">
+          <UIcon v-if="icon" :name="icon" :class="ui.icon({ class: props.ui?.icon })" />
+        </slot>
+
+        <h1 :class="ui.title({ class: props.ui?.title })">
+          <slot name="title">
+            {{ title }}
+          </slot>
+        </h1>
+
+        <slot name="trailing" v-bind="dashboardContext" />
+      </slot>
+    </div>
+
+    <div v-if="!!slots.default" :class="ui.center({ class: props.ui?.center })">
+      <slot v-bind="dashboardContext" />
+    </div>
+
+    <div :class="ui.right({ class: props.ui?.right })">
+      <slot name="right" v-bind="dashboardContext" />
+
+      <ReuseToggleTemplate v-if="toggleSide === 'right'" />
+    </div>
+  </Primitive>
+</template>

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

@@ -0,0 +1,52 @@
+import type { AppConfig } from '@nuxt/schema';
+import theme from '#build/ui/dashboard-navbar';
+import type { DashboardContext } from '../utils/dashboard';
+import type { ButtonProps, IconProps } from '../types';
+import type { ComponentConfig } from '../types/tv';
+type DashboardNavbar = ComponentConfig<typeof theme, AppConfig, 'dashboardNavbar'>;
+export interface DashboardNavbarProps {
+    /**
+     * The element or component this component should render as.
+     * @defaultValue 'div'
+     */
+    as?: any;
+    /**
+     * The icon displayed next to the title.
+     * @IconifyIcon
+     */
+    icon?: IconProps['name'];
+    title?: string;
+    /**
+     * 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?: DashboardNavbar['slots'];
+}
+type DashboardNavbarSlotsProps = Omit<DashboardContext, 'storage' | 'storageKey' | 'persistent' | 'unit'>;
+export interface DashboardNavbarSlots {
+    title(props?: {}): any;
+    leading(props: DashboardNavbarSlotsProps): any;
+    trailing(props: DashboardNavbarSlotsProps): any;
+    left(props: DashboardNavbarSlotsProps): any;
+    default(props: DashboardNavbarSlotsProps): any;
+    right(props: DashboardNavbarSlotsProps): any;
+    toggle(props: DashboardNavbarSlotsProps): any;
+}
+declare const _default: __VLS_WithSlots<import("vue").DefineComponent<DashboardNavbarProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<DashboardNavbarProps> & Readonly<{}>, {
+    toggle: boolean | Partial<ButtonProps>;
+    toggleSide: "left" | "right";
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, DashboardNavbarSlots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/DashboardPanel.vue

@@ -0,0 +1,62 @@
+<script>
+import theme from "#build/ui/dashboard-panel";
+</script>
+
+<script setup>
+import { computed, useId, toRef } from "vue";
+import { useAppConfig } from "#imports";
+import { useResizable } from "../composables/useResizable";
+import { useDashboard } from "../utils/dashboard";
+import { tv } from "../utils/tv";
+import UDashboardResizeHandle from "./DashboardResizeHandle.vue";
+defineOptions({ inheritAttrs: false });
+const props = defineProps({
+  class: { type: null, required: false },
+  ui: { type: null, required: false },
+  id: { type: String, required: false },
+  minSize: { type: Number, required: false, default: 15 },
+  maxSize: { type: Number, required: false },
+  defaultSize: { type: Number, required: false },
+  resizable: { type: Boolean, required: false, default: false }
+});
+defineSlots();
+const appConfig = useAppConfig();
+const dashboardContext = useDashboard({ storageKey: "dashboard", unit: "%" });
+const id = `${dashboardContext.storageKey}-panel-${props.id || useId()}`;
+const { el, size, isDragging, onMouseDown, onTouchStart, onDoubleClick } = useResizable(id, toRef(() => ({ ...dashboardContext, ...props })));
+const ui = computed(() => tv({ extend: tv(theme), ...appConfig.ui?.dashboardPanel || {} })({
+  size: !!size.value
+}));
+</script>
+
+<template>
+  <div
+    :id="id"
+    ref="el"
+    v-bind="$attrs"
+    :data-dragging="isDragging"
+    :class="ui.root({ class: [props.ui?.root, props.class] })"
+    :style="[size ? { '--width': `${size}${dashboardContext.unit}` } : void 0]"
+  >
+    <slot>
+      <slot name="header" />
+
+      <div :class="ui.body({ class: props.ui?.body })">
+        <slot name="body" />
+      </div>
+
+      <slot name="footer" />
+    </slot>
+  </div>
+
+  <slot name="resize-handle" :on-mouse-down="onMouseDown" :on-touch-start="onTouchStart" :on-double-click="onDoubleClick">
+    <UDashboardResizeHandle
+      v-if="resizable"
+      :aria-controls="id"
+      :class="ui.handle({ class: props.ui?.handle })"
+      @mousedown="onMouseDown"
+      @touchstart="onTouchStart"
+      @dblclick="onDoubleClick"
+    />
+  </slot>
+</template>

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

@@ -0,0 +1,30 @@
+import type { AppConfig } from '@nuxt/schema';
+import theme from '#build/ui/dashboard-panel';
+import type { UseResizableProps } from '../composables/useResizable';
+import type { ComponentConfig } from '../types/tv';
+type DashboardPanel = ComponentConfig<typeof theme, AppConfig, 'dashboardPanel'>;
+export interface DashboardPanelProps extends Pick<UseResizableProps, 'id' | 'minSize' | 'maxSize' | 'defaultSize' | 'resizable'> {
+    class?: any;
+    ui?: DashboardPanel['slots'];
+}
+export interface DashboardPanelSlots {
+    'default'(props?: {}): any;
+    'header'(props?: {}): any;
+    'body'(props?: {}): any;
+    'footer'(props?: {}): any;
+    'resize-handle'(props: {
+        onMouseDown: (e: MouseEvent) => void;
+        onTouchStart: (e: TouchEvent) => void;
+        onDoubleClick: (e: MouseEvent) => void;
+    }): any;
+}
+declare const _default: __VLS_WithSlots<import("vue").DefineComponent<DashboardPanelProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<DashboardPanelProps> & Readonly<{}>, {
+    minSize: number;
+    resizable: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, DashboardPanelSlots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/DashboardResizeHandle.vue

@@ -0,0 +1,27 @@
+<script>
+import theme from "#build/ui/dashboard-resize-handle";
+</script>
+
+<script setup>
+import { computed } from "vue";
+import { Primitive } from "reka-ui";
+import { useAppConfig } from "#imports";
+import { tv } from "../utils/tv";
+const props = defineProps({
+  as: { type: null, required: false },
+  class: { type: null, required: false }
+});
+defineSlots();
+const appConfig = useAppConfig();
+const ui = computed(() => tv({ extend: tv(theme), ...appConfig.ui?.dashboardResizeHandle || {} }));
+</script>
+
+<template>
+  <Primitive
+    :as="as"
+    role="separator"
+    :class="ui({ class: props.class })"
+  >
+    <slot />
+  </Primitive>
+</template>

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

@@ -0,0 +1,18 @@
+export interface DashboardResizeHandleProps {
+    /**
+     * The element or component this component should render as.
+     * @defaultValue 'div'
+     */
+    as?: any;
+    class?: any;
+}
+export interface DashboardResizeHandleSlots {
+    default(props?: {}): any;
+}
+declare const _default: __VLS_WithSlots<import("vue").DefineComponent<DashboardResizeHandleProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<DashboardResizeHandleProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, DashboardResizeHandleSlots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/DashboardSearch.vue

@@ -0,0 +1,124 @@
+<script>
+import theme from "#build/ui/dashboard-search";
+</script>
+
+<script setup>
+import { computed, useTemplateRef } from "vue";
+import { useForwardProps } from "reka-ui";
+import { defu } from "defu";
+import { reactivePick } from "@vueuse/core";
+import { useAppConfig, useColorMode, defineShortcuts, useRuntimeHook } from "#imports";
+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, Object], required: false },
+  placeholder: { type: String, required: false },
+  autofocus: { type: Boolean, required: false },
+  loading: { type: Boolean, required: false },
+  loadingIcon: { type: [String, Object], required: false },
+  close: { type: [Boolean, Object], required: false, default: true },
+  closeIcon: { type: [String, Object], required: false },
+  shortcut: { type: String, required: false, default: "meta_k" },
+  groups: { type: Array, required: false },
+  fuse: { type: Object, required: false },
+  colorMode: { type: Boolean, required: false, default: true },
+  class: { type: null, required: false },
+  ui: { type: void 0, required: false }
+});
+const slots = defineSlots();
+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 } = 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 ui = computed(() => tv({ extend: tv(theme), ...appConfig.ui?.dashboardSearch || {} })());
+const groups = computed(() => {
+  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: 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 groups2;
+});
+function onSelect(item) {
+  if (item.disabled) {
+    return;
+  }
+  open.value = false;
+  searchTerm.value = "";
+}
+defineShortcuts({
+  [props.shortcut]: {
+    usingInput: true,
+    handler: () => open.value = !open.value
+  }
+});
+const commandPaletteRef = useTemplateRef("commandPaletteRef");
+defineExpose({
+  commandPaletteRef
+});
+</script>
+
+<template>
+  <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
+          ref="commandPaletteRef"
+          v-model:search-term="searchTerm"
+          v-bind="commandPaletteProps"
+          :groups="groups"
+          :fuse="fuse"
+          :ui="transformUI(omit(ui, ['modal']), props.ui)"
+          @update:model-value="onSelect"
+          @update:open="open = $event"
+        >
+          <template v-for="(_, name) in proxySlots" #[name]="slotData">
+            <slot :name="name" v-bind="slotData" />
+          </template>
+        </UCommandPalette>
+      </slot>
+    </template>
+  </UModal>
+</template>

package/dist/runtime/components/DashboardSearch.vue.d.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/DashboardSearchButton.vue

@@ -0,0 +1,82 @@
+<script>
+import theme from "#build/ui/dashboard-search-button";
+</script>
+
+<script setup>
+import { computed, toRef } from "vue";
+import { useForwardProps } from "reka-ui";
+import { defu } from "defu";
+import { reactivePick, createReusableTemplate } from "@vueuse/core";
+import { useAppConfig } from "#imports";
+import { useLocale } from "../composables/useLocale";
+import { useDashboard } from "../utils/dashboard";
+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, Object], required: false },
+  label: { type: String, required: false },
+  color: { type: null, required: false, default: "neutral" },
+  variant: { type: null, required: false },
+  size: { type: null, required: false },
+  collapsed: { type: Boolean, required: false, default: false },
+  tooltip: { type: [Boolean, Object], required: false, default: false },
+  kbds: { type: Array, required: false, default: () => ["meta", "k"] },
+  ui: { type: void 0, required: false },
+  class: { type: null, required: false }
+});
+const slots = defineSlots();
+const [DefineButtonTemplate, ReuseButtonTemplate] = createReusableTemplate();
+const proxySlots = 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="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 v-for="(_, name) in proxySlots" #[name]="slotData">
+        <slot :name="name" v-bind="slotData" />
+      </template>
+
+      <template v-if="!collapsed" #trailing>
+        <div :class="ui.trailing({ class: props.ui?.trailing })">
+          <slot name="trailing">
+            <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>
+      </template>
+    </UButton>
+  </DefineButtonTemplate>
+
+  <UTooltip v-if="collapsed && tooltip" :text="label || t('dashboardSearchButton.label')" v-bind="tooltipProps">
+    <ReuseButtonTemplate />
+  </UTooltip>
+  <ReuseButtonTemplate v-else />
+</template>