@nuxt/ui 3.3.1 → 4.0.0-alpha.0

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, void, {}, {}, {}, 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, required: false },
+  placeholder: { type: String, required: false },
+  autofocus: { type: Boolean, required: false },
+  loading: { type: Boolean, required: false },
+  loadingIcon: { type: String, required: false },
+  close: { type: [Boolean, Object], required: false, default: true },
+  closeIcon: { type: String, 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 } 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?: string;
+    /**
+     * 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?: string;
+    /**
+     * 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?: string;
+    /**
+     * 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, 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>

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

@@ -0,0 +1,59 @@
+import type { AppConfig } from '@nuxt/schema';
+import theme from '#build/ui/dashboard-search-button';
+import type { ButtonProps, ButtonSlots, 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;
+    /**
+     * 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, void, {}, {}, {}, 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/DashboardSidebar.vue

@@ -0,0 +1,162 @@
+<script>
+import theme from "#build/ui/dashboard-sidebar";
+</script>
+
+<script setup>
+import { ref, computed, toRef, useId, watch } from "vue";
+import { defu } from "defu";
+import { createReusableTemplate } from "@vueuse/core";
+import { useAppConfig, useRuntimeHook, useRoute } from "#imports";
+import { useResizable } from "../composables/useResizable";
+import { useLocale } from "../composables/useLocale";
+import { useDashboard } from "../utils/dashboard";
+import { tv } from "../utils/tv";
+import UDashboardResizeHandle from "./DashboardResizeHandle.vue";
+import UDashboardSidebarToggle from "./DashboardSidebarToggle.vue";
+import USlideover from "./Slideover.vue";
+import UModal from "./Modal.vue";
+import UDrawer from "./Drawer.vue";
+defineOptions({ inheritAttrs: false });
+const props = defineProps({
+  mode: { type: null, required: false, default: "slideover" },
+  menu: { type: null, 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 },
+  id: { type: String, required: false },
+  side: { type: String, required: false, default: "left" },
+  minSize: { type: Number, required: false, default: 10 },
+  maxSize: { type: Number, required: false, default: 20 },
+  defaultSize: { type: Number, required: false, default: 15 },
+  resizable: { type: Boolean, required: false, default: false },
+  collapsible: { type: Boolean, required: false, default: false },
+  collapsedSize: { type: Number, required: false, default: 0 }
+});
+const slots = defineSlots();
+const open = defineModel("open", { type: Boolean, ...{ default: false } });
+const collapsed = defineModel("collapsed", { type: Boolean, ...{ default: false } });
+const route = useRoute();
+const { t } = useLocale();
+const appConfig = useAppConfig();
+const dashboardContext = useDashboard({
+  storageKey: "dashboard",
+  unit: "%",
+  sidebarOpen: ref(false),
+  sidebarCollapsed: ref(false)
+});
+const id = `${dashboardContext.storageKey}-sidebar-${props.id || useId()}`;
+const { el, size, collapse, isCollapsed, isDragging, onMouseDown, onTouchStart, onDoubleClick } = useResizable(id, toRef(() => ({ ...dashboardContext, ...props })), { collapsed });
+const [DefineToggleTemplate, ReuseToggleTemplate] = createReusableTemplate();
+const [DefineResizeHandleTemplate, ReuseResizeHandleTemplate] = createReusableTemplate();
+useRuntimeHook("dashboard:sidebar:toggle", () => {
+  open.value = !open.value;
+});
+useRuntimeHook("dashboard:sidebar:collapse", (value) => {
+  isCollapsed.value = value;
+});
+watch(open, () => dashboardContext.sidebarOpen.value = open.value, { immediate: true });
+watch(isCollapsed, () => dashboardContext.sidebarCollapsed.value = isCollapsed.value, { immediate: true });
+watch(() => route.fullPath, () => {
+  open.value = false;
+});
+const ui = computed(() => tv({ extend: tv(theme), ...appConfig.ui?.dashboardSidebar || {} })({
+  side: props.side
+}));
+const Menu = computed(() => ({
+  slideover: USlideover,
+  modal: UModal,
+  drawer: UDrawer
+})[props.mode]);
+const menuProps = toRef(() => defu(props.menu, {
+  content: {
+    onOpenAutoFocus: (e) => e.preventDefault()
+  }
+}, props.mode === "modal" ? { fullscreen: true, transition: false } : props.mode === "slideover" ? { side: "left" } : {}));
+function toggleOpen() {
+  open.value = !open.value;
+}
+</script>
+
+<template>
+  <DefineToggleTemplate>
+    <slot name="toggle" :open="open" :toggle="toggleOpen">
+      <UDashboardSidebarToggle
+        v-if="toggle"
+        v-bind="typeof toggle === 'object' ? toggle : {}"
+        :side="toggleSide"
+        :class="ui.toggle({ class: props.ui?.toggle, toggleSide })"
+      />
+    </slot>
+  </DefineToggleTemplate>
+
+  <DefineResizeHandleTemplate>
+    <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>
+  </DefineResizeHandleTemplate>
+
+  <ReuseResizeHandleTemplate v-if="side === 'right'" />
+
+  <div
+    :id="id"
+    ref="el"
+    v-bind="$attrs"
+    :data-collapsed="isCollapsed"
+    :data-dragging="isDragging"
+    :class="ui.root({ class: [props.ui?.root, props.class] })"
+    :style="{ '--width': `${size || 0}${dashboardContext.unit}` }"
+  >
+    <div v-if="!!slots.header" :class="ui.header({ class: props.ui?.header })">
+      <slot name="header" :collapsed="isCollapsed" :collapse="collapse" />
+    </div>
+
+    <div :class="ui.body({ class: props.ui?.body })">
+      <slot :collapsed="isCollapsed" :collapse="collapse" />
+    </div>
+
+    <div v-if="!!slots.footer" :class="ui.footer({ class: props.ui?.footer })">
+      <slot name="footer" :collapsed="isCollapsed" :collapse="collapse" />
+    </div>
+  </div>
+
+  <ReuseResizeHandleTemplate v-if="side === 'left'" />
+
+  <Menu
+    v-model:open="open"
+    :title="t('dashboardSidebar.title')"
+    :description="t('dashboardSidebar.description')"
+    v-bind="menuProps"
+    :ui="{
+  overlay: ui.overlay({ class: props.ui?.overlay }),
+  content: ui.content({ class: props.ui?.content })
+}"
+  >
+    <template #content>
+      <slot name="content">
+        <div v-if="!!slots.header || mode !== 'drawer'" :class="ui.header({ class: props.ui?.header, menu: true })">
+          <ReuseToggleTemplate v-if="mode !== 'drawer' && toggleSide === 'left'" />
+
+          <slot name="header" />
+
+          <ReuseToggleTemplate v-if="mode !== 'drawer' && toggleSide === 'right'" />
+        </div>
+
+        <div :class="ui.body({ class: props.ui?.body, menu: true })">
+          <slot />
+        </div>
+
+        <div v-if="!!slots.footer" :class="ui.footer({ class: props.ui?.footer, menu: true })">
+          <slot name="footer" />
+        </div>
+      </slot>
+    </template>
+  </Menu>
+</template>

package/dist/runtime/components/DashboardSidebar.vue.d.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;
+    }) & Partial<{}>> & 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];
+} & {};

package/dist/runtime/components/DashboardSidebarCollapse.vue

@@ -0,0 +1,36 @@
+<script>
+import theme from "#build/ui/dashboard-sidebar-collapse";
+</script>
+
+<script setup>
+import { ref, computed } from "vue";
+import { useForwardProps } from "reka-ui";
+import { reactivePick } from "@vueuse/core";
+import { useAppConfig } from "#imports";
+import { useLocale } from "../composables/useLocale";
+import { useDashboard } from "../utils/dashboard";
+import { tv } from "../utils/tv";
+import UButton from "./Button.vue";
+const props = defineProps({
+  side: { type: String, required: false, default: "left" },
+  color: { type: null, required: false, default: "neutral" },
+  variant: { type: null, required: false, default: "ghost" },
+  class: { type: null, required: false }
+});
+const rootProps = useForwardProps(reactivePick(props, "color", "variant", "size"));
+const { t } = useLocale();
+const appConfig = useAppConfig();
+const { sidebarCollapsed, collapseSidebar } = useDashboard({ sidebarCollapsed: ref(false), collapseSidebar: () => {
+} });
+const ui = computed(() => tv({ extend: tv(theme), ...appConfig.ui?.dashboardSidebarCollapse || {} }));
+</script>
+
+<template>
+  <UButton
+    v-bind="rootProps"
+    :aria-label="sidebarCollapsed ? t('dashboardSidebarCollapse.expand') : t('dashboardSidebarCollapse.collapse')"
+    :icon="sidebarCollapsed ? appConfig.ui.icons.panelOpen : appConfig.ui.icons.panelClose"
+    :class="ui({ class: props.class, side: props.side })"
+    @click="collapseSidebar?.(!sidebarCollapsed)"
+  />
+</template>

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

@@ -0,0 +1,19 @@
+import type { ButtonProps } from '../types';
+export interface DashboardSidebarCollapseProps extends /** @vue-ignore */ Pick<ButtonProps, 'as' | 'size' | 'disabled' | 'ui'> {
+    side?: 'left' | 'right';
+    /**
+     * @defaultValue 'neutral'
+     */
+    color?: ButtonProps['color'];
+    /**
+     * @defaultValue 'ghost'
+     */
+    variant?: ButtonProps['variant'];
+    class?: any;
+}
+declare const _default: import("vue").DefineComponent<DashboardSidebarCollapseProps, void, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<DashboardSidebarCollapseProps> & Readonly<{}>, {
+    color: "error" | "primary" | "secondary" | "success" | "info" | "warning" | "neutral";
+    variant: "link" | "solid" | "outline" | "soft" | "subtle" | "ghost";
+    side: "left" | "right";
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;