@eslamdevui/ui 3.2.0-beta.1

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

@@ -0,0 +1,27 @@
+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";
+    as: any;
+    storageKey: string;
+    persistent: boolean;
+    unit: "%" | "rem" | "px";
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+    default?: (props: {}) => any;
+}>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/DashboardNavbar.vue

@@ -0,0 +1,74 @@
+<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";
+const props = defineProps({
+  as: { type: null, required: false, default: "div" },
+  icon: { type: String, 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 }
+});
+defineSlots();
+const dashboardContext = useDashboard();
+const appConfig = useAppConfig();
+const [DefineToggleTemplate, ReuseToggleTemplate] = createReusableTemplate();
+const uiPro = computed(
+  () => tv({
+    extend: tv(theme),
+    ...appConfig.ui?.dashboardNavbar
+  })
+);
+</script>
+
+<template>
+  <DefineToggleTemplate>
+    <slot name="toggle" v-bind="dashboardContext">
+      <UDashboardSidebarToggle
+        v-if="props.toggle"
+        v-bind="typeof props.toggle === 'object' ? props.toggle : {}"
+        :side="props.toggleSide"
+        :class="uiPro.toggle({ class: props.ui?.toggle, toggleSide: props.toggleSide })"
+      />
+    </slot>
+  </DefineToggleTemplate>
+
+  <Primitive :as="props.as" :class="uiPro.root({ class: [props.ui?.root, props.class] })">
+    <div :class="uiPro.left({ class: props.ui?.left })">
+      <ReuseToggleTemplate v-if="props.toggleSide === 'left'" />
+
+      <slot name="left" v-bind="dashboardContext">
+        <slot name="leading" v-bind="dashboardContext">
+          <UIcon v-if="props.icon" :name="props.icon" :class="uiPro.icon({ class: props.ui?.icon })" />
+        </slot>
+
+        <h1 :class="uiPro.title({ class: props.ui?.title })">
+          <slot name="title">
+            {{ props.title }}
+          </slot>
+        </h1>
+
+        <slot name="trailing" v-bind="dashboardContext" />
+      </slot>
+    </div>
+
+    <div v-if="!!slots.default" :class="uiPro.center({ class: props.ui?.center })">
+      <slot v-bind="dashboardContext" />
+    </div>
+
+    <div :class="uiPro.right({ class: props.ui?.right })">
+      <slot name="right" v-bind="dashboardContext" />
+
+      <ReuseToggleTemplate v-if="props.toggleSide === 'right'" />
+    </div>
+  </Primitive>
+</template>

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

@@ -0,0 +1,53 @@
+import type { AppConfig } from '@nuxt/schema';
+import type { ButtonProps, ComponentConfig } from '@nuxt/ui';
+import type { DashboardContext } from '../utils/dashboard';
+import theme from '#build/ui/dashboard-navbar';
+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?: string;
+    title?: string;
+    /**
+     * Customize the toggle button to open the sidebar.
+     * `{ color: 'neutral', variant: 'ghost' }`
+     * @defaultValue true
+     */
+    toggle?: boolean | Partial<ButtonProps>;
+    /**
+     * The side to render the toggle button on.
+     * @defaultValue 'left'
+     */
+    toggleSide?: 'left' | 'right';
+    class?: any;
+    ui?: DashboardNavbar['slots'];
+}
+export interface DashboardNavbarSlotsProps extends 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>;
+    as: any;
+    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,56 @@
+<script>
+import theme from "#build/ui/dashboard-panel";
+</script>
+
+<script setup>
+import { useId, toRef } from "vue";
+import { useAppConfig } from "#imports";
+import { useResizable } from "../composables/useResizable";
+import { useDashboard } from "../utils/dashboard";
+import { tv } from "../utils/tv";
+const props = defineProps({
+  class: { type: null, required: false },
+  ui: { type: null, required: false },
+  id: { type: String, required: false },
+  minSize: { type: Number, required: false },
+  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 panelId = `${dashboardContext.storageKey}-panel-${props.id || useId()}`;
+const { el, size, isDragging, onMouseDown, onTouchStart } = useResizable(panelId, toRef(() => ({ ...dashboardContext, ...props })));
+const uiPro = tv({ extend: tv(theme), ...appConfig.ui?.dashboardPanel });
+</script>
+
+<template>
+  <div
+    :id="panelId"
+    ref="el"
+    :data-dragging="isDragging"
+    :class="uiPro.root({ class: [props.ui?.root, props.class] })"
+    :style="size ? { '--width': `${size}${dashboardContext.unit}` } : void 0"
+  >
+    <slot>
+      <slot name="header" />
+
+      <div :class="uiPro.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">
+    <UDashboardResizeHandle
+      v-if="props.resizable"
+      :aria-controls="panelId"
+      :class="uiPro.handle({ class: props.ui?.handle })"
+      @mousedown="onMouseDown"
+      @touchstart="onTouchStart"
+    />
+  </slot>
+</template>

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

@@ -0,0 +1,28 @@
+import type { AppConfig } from '@nuxt/schema';
+import type { ComponentConfig } from '@nuxt/ui';
+import type { UseResizableProps } from '../composables/useResizable';
+import theme from '#build/ui/dashboard-panel';
+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;
+    }): any;
+}
+declare const _default: __VLS_WithSlots<import("vue").DefineComponent<DashboardPanelProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<DashboardPanelProps> & Readonly<{}>, {
+    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,32 @@
+<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,22 @@
+import type { AppConfig } from '@nuxt/schema';
+import theme from '#build/ui/dashboard-resize-handle';
+import type { ComponentConfig } from '../types';
+export type DashboardResizeHandle = ComponentConfig<typeof theme, AppConfig, 'dashboardResizeHandle'>;
+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>, __VLS_Slots>;
+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 { omit } from "@nuxt/ui/utils";
+import { useAppConfig, useColorMode, defineShortcuts, useRuntimeHook } from "#imports";
+import { useLocalePro } from "../composables/useLocalePro";
+import { transformUI } from "../utils";
+import { tv } from "../utils/tv";
+const props = defineProps({
+  icon: { type: String, required: false },
+  placeholder: { type: null, 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 } = useLocalePro();
+const colorModeComposable = 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 = tv({
+  extend: tv(theme),
+  ...appConfig.ui?.dashboardSearch
+});
+const groups = computed(() => {
+  const arr = [...props.groups || []];
+  if (props.colorMode && !colorModeComposable?.forced) {
+    arr.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";
+          }
+        }
+      ]
+    });
+  }
+  return arr;
+});
+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" :class="uiPro.modal({ class: props.class })">
+    <template #content>
+      <slot name="content">
+        <UCommandPalette
+          ref="commandPaletteRef"
+          v-model:search-term="searchTerm"
+          v-bind="commandPaletteProps"
+          :groups="groups"
+          :fuse="fuse"
+          :ui="transformUI(uiPro, 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>
+        </UCommandPalette>
+      </slot>
+    </template>
+  </UModal>
+</template>

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

@@ -0,0 +1,48 @@
+import type { AppConfig } from '@nuxt/schema';
+import type { ButtonProps, InputProps, CommandPaletteProps, CommandPaletteSlots, CommandPaletteGroup, CommandPaletteItem, ComponentConfig } from '@eslamdevui/ui';
+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;
+    placeholder?: InputProps['placeholder'];
+    autofocus?: boolean;
+    loading?: boolean;
+    loadingIcon?: string;
+    close?: boolean | Partial<ButtonProps>;
+    closeIcon?: string;
+    shortcut?: string;
+    groups?: CommandPaletteGroup<T>[];
+    fuse?: UseFuseOptions<T>;
+    colorMode?: boolean;
+    class?: any;
+    ui?: DashboardSearch<T>['slots'] & CommandPaletteProps<CommandPaletteGroup<T>, T>['ui'];
+}
+export type DashboardSearchSlots<T extends CommandPaletteItem = CommandPaletteItem> = CommandPaletteSlots<CommandPaletteGroup<T>, T> & {
+    content(props?: {}): any;
+};
+declare const _default: __VLS_WithSlots<import("vue").DefineComponent<DashboardSearchProps<CommandPaletteItem> & {
+    open?: boolean;
+    searchTerm?: string;
+}, {
+    commandPaletteRef: Readonly<import("vue").ShallowRef<unknown>>;
+}, {}, {}, {}, 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>, any>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/DashboardSearchButton.vue

@@ -0,0 +1,72 @@
+<script>
+import theme from "#build/ui/dashboard-search-button";
+</script>
+
+<script setup>
+import { computed } from "vue";
+import { useForwardProps } from "reka-ui";
+import { reactivePick } from "@vueuse/core";
+import { omit } from "@nuxt/ui/utils";
+import { useAppConfig } from "#imports";
+import { useLocalePro } from "../composables/useLocalePro";
+import { useDashboard } from "../utils/dashboard";
+import { transformUI } from "../utils";
+import { tv } from "../utils/tv";
+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 },
+  kbds: { type: Array, required: false, default: () => ["meta", "k"] },
+  ui: { type: void 0, required: false },
+  class: { type: null, required: false }
+});
+defineSlots();
+const proxySlots = omit(defineSlots(), ["trailing"]);
+const rootProps = useForwardProps(reactivePick(props, "color", "size", "variant"));
+const { t } = useLocalePro();
+const appConfig = useAppConfig();
+const { toggleSearch } = useDashboard();
+const dashboardSearchButtonUI = computed(
+  () => tv({
+    extend: tv(theme),
+    ...appConfig.ui?.dashboardSearchButton
+  })
+);
+</script>
+
+<template>
+  <UButton
+    :icon="props.icon || appConfig.ui.icons.search"
+    :label="props.label || t('dashboardSearchButton.label')"
+    v-bind="{
+  ...rootProps,
+  ...props.collapsed ? { 'square': true, 'label': void 0, 'aria-label': props.label || t('dashboardSearchButton.label') } : {}
+}"
+    :variant="props.variant || (props.collapsed ? 'ghost' : 'outline')"
+    :class="dashboardSearchButtonUI.base({ class: [props.ui?.base, props.class] })"
+    :ui="transformUI(dashboardSearchButtonUI, props.ui)"
+    @click="toggleSearch"
+  >
+    <template v-for="(_, name) in proxySlots" #[name]="slotData">
+      <slot :name="name" v-bind="slotData" />
+    </template>
+
+    <template v-if="!props.collapsed" #trailing>
+      <div :class="dashboardSearchButtonUI.trailing({ class: props.ui?.trailing })">
+        <slot name="trailing">
+          <template v-if="props.kbds?.length">
+            <UKbd
+              v-for="(kbd, idx) in props.kbds"
+              :key="idx"
+              variant="subtle"
+              v-bind="typeof kbd === 'string' ? { value: kbd } : kbd"
+            />
+          </template>
+        </slot>
+      </div>
+    </template>
+  </UButton>
+</template>

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

@@ -0,0 +1,52 @@
+import type { AppConfig } from '@nuxt/schema';
+import type { ButtonProps, KbdProps, ComponentConfig } from '@nuxt/ui';
+import theme from '#build/ui/dashboard-search-button';
+export 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;
+    /**
+     * 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" | "info" | "primary" | "secondary" | "success" | "warning" | "neutral";
+    kbds: KbdProps["value"][] | KbdProps[];
+    collapsed: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};