@eslamdevui/ui 3.3.4 → 4.0.0-beta

package/dist/runtime/utils/form.d.ts

@@ -1,13 +1,9 @@
 import type { StandardSchemaV1 } from '@standard-schema/spec';
-import type { ValidationError as JoiError, Schema as JoiSchema } from 'joi';
-import type { ObjectSchema as YupObjectSchema, ValidationError as YupError } from 'yup';
 import type { Struct } from 'superstruct';
 import type { FormSchema, ValidateReturnSchema } from '../types/form';
-export declare function isYupSchema(schema: any): schema is YupObjectSchema<any>;
-export declare function isYupError(error: any): error is YupError;
 export declare function isSuperStructSchema(schema: any): schema is Struct<any, any>;
-export declare function isJoiSchema(schema: any): schema is JoiSchema;
-export declare function isJoiError(error: any): error is JoiError;
 export declare function isStandardSchema(schema: any): schema is StandardSchemaV1;
 export declare function validateStandardSchema(state: any, schema: StandardSchemaV1): Promise<ValidateReturnSchema<typeof state>>;
 export declare function validateSchema<T extends object>(state: T, schema: FormSchema<T>): Promise<ValidateReturnSchema<typeof state>>;
+export declare function getAtPath<T extends object>(data: T, path?: string): any;
+export declare function setAtPath<T extends object>(data: T, path: string, value: any): T;

package/dist/runtime/utils/form.js

@@ -1,18 +1,6 @@
-export function isYupSchema(schema) {
-  return schema.validate && schema.__isYupSchema__;
-}
-export function isYupError(error) {
-  return error.inner !== void 0;
-}
 export function isSuperStructSchema(schema) {
   return "schema" in schema && typeof schema.coercer === "function" && typeof schema.validator === "function" && typeof schema.refiner === "function";
 }
-export function isJoiSchema(schema) {
-  return schema.validateAsync !== void 0 && schema.id !== void 0;
-}
-export function isJoiError(error) {
-  return error.isJoi === true;
-}
 export function isStandardSchema(schema) {
   return "~standard" in schema;
 }
@@ -32,28 +20,6 @@ export async function validateStandardSchema(state, schema) {
     result: result.value
   };
 }
-async function validateYupSchema(state, schema) {
-  try {
-    const result = await schema.validate(state, { abortEarly: false });
-    return {
-      errors: null,
-      result
-    };
-  } catch (error) {
-    if (isYupError(error)) {
-      const errors = error.inner.map((issue) => ({
-        name: issue.path ?? "",
-        message: issue.message
-      }));
-      return {
-        errors,
-        result: null
-      };
-    } else {
-      throw error;
-    }
-  }
-}
 async function validateSuperstructSchema(state, schema) {
   const [err, result] = schema.validate(state);
   if (err) {
@@ -71,38 +37,40 @@ async function validateSuperstructSchema(state, schema) {
     result
   };
 }
-async function validateJoiSchema(state, schema) {
-  try {
-    const result = await schema.validateAsync(state, { abortEarly: false });
-    return {
-      errors: null,
-      result
-    };
-  } catch (error) {
-    if (isJoiError(error)) {
-      const errors = error.details.map((issue) => ({
-        name: issue.path.join("."),
-        message: issue.message
-      }));
-      return {
-        errors,
-        result: null
-      };
-    } else {
-      throw error;
-    }
-  }
-}
 export function validateSchema(state, schema) {
   if (isStandardSchema(schema)) {
     return validateStandardSchema(state, schema);
-  } else if (isJoiSchema(schema)) {
-    return validateJoiSchema(state, schema);
-  } else if (isYupSchema(schema)) {
-    return validateYupSchema(state, schema);
   } else if (isSuperStructSchema(schema)) {
     return validateSuperstructSchema(state, schema);
   } else {
     throw new Error("Form validation failed: Unsupported form schema");
   }
 }
+export function getAtPath(data, path) {
+  if (!path) return data;
+  const value = path.split(".").reduce(
+    (value2, key) => value2?.[key],
+    data
+  );
+  return value;
+}
+export function setAtPath(data, path, value) {
+  if (!path) return Object.assign(data, value);
+  if (!data) return data;
+  const keys = path.split(".");
+  let current = data;
+  for (let i = 0; i < keys.length - 1; i++) {
+    const key = keys[i];
+    if (current[key] === void 0 || current[key] === null) {
+      if (i + 1 < keys.length && !Number.isNaN(Number(keys[i + 1]))) {
+        current[key] = [];
+      } else {
+        current[key] = {};
+      }
+    }
+    current = current[key];
+  }
+  const lastKey = keys[keys.length - 1];
+  current[lastKey] = value;
+  return data;
+}

package/dist/runtime/utils/fuse.d.ts

@@ -1,4 +1,5 @@
 import type { FuseResult } from 'fuse.js';
+import type { GetItemKeys } from '../types/utils';
 export declare function highlight<T>(item: T & {
     matches?: FuseResult<T>['matches'];
-}, searchTerm: string, forceKey?: string, omitKeys?: string[]): string | undefined;
+}, searchTerm: string, forceKey?: GetItemKeys<T>, omitKeys?: GetItemKeys<T>[]): string | undefined;

package/dist/runtime/utils/index.d.ts

@@ -1,13 +1,17 @@
+import type { GetItemKeys } from '../types/utils';
 export declare function pick<Data extends object, Keys extends keyof Data>(data: Data, keys: Keys[]): Pick<Data, Keys>;
 export declare function omit<Data extends object, Keys extends keyof Data>(data: Data, keys: Keys[]): Omit<Data, Keys>;
 export declare function get(object: Record<string, any> | undefined, path: (string | number)[] | string, defaultValue?: any): any;
 export declare function set(object: Record<string, any>, path: (string | number)[] | string, value: any): void;
 export declare function looseToNumber(val: any): any;
 export declare function compare<T>(value?: T, currentValue?: T, comparator?: string | ((a: T, b: T) => boolean)): boolean;
+export declare function isEmpty(value: unknown): boolean;
+export declare function getDisplayValue<T extends Array<any>, V>(items: T, value: V | undefined | null, options?: {
+    valueKey?: GetItemKeys<T>;
+    labelKey?: GetItemKeys<T>;
+}): string | undefined;
 export declare function isArrayOfArray<A>(item: A[] | A[][]): item is A[][];
 export declare function mergeClasses(appConfigClass?: string | string[], propClass?: string): "" | (string | undefined)[];
-export declare function getSlotChildrenText(children: any): string;
-export declare function transformUI(ui: Record<string, ((args: {
-    class?: string;
-}) => any) | any>, uiProp?: Record<string, any>): Record<string, any>;
+export declare function getSlotChildrenText(children: any): any;
+export declare function transformUI(ui: any, uiProp?: any): any;
 export * from './content';

package/dist/runtime/utils/index.js

@@ -61,6 +61,56 @@ export function compare(value, currentValue, comparator) {
   }
   return isEqual(value, currentValue);
 }
+export function isEmpty(value) {
+  if (value == null) {
+    return true;
+  }
+  if (typeof value === "boolean" || typeof value === "number") {
+    return false;
+  }
+  if (typeof value === "string") {
+    return value.trim().length === 0;
+  }
+  if (Array.isArray(value)) {
+    return value.length === 0;
+  }
+  if (value instanceof Map || value instanceof Set) {
+    return value.size === 0;
+  }
+  if (value instanceof Date || value instanceof RegExp || typeof value === "function") {
+    return false;
+  }
+  if (typeof value === "object") {
+    for (const _ in value) {
+      if (Object.prototype.hasOwnProperty.call(value, _)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  return false;
+}
+export function getDisplayValue(items, value, options = {}) {
+  const { valueKey, labelKey } = options;
+  const foundItem = items.find((item) => {
+    const itemValue = typeof item === "object" && item !== null && valueKey ? get(item, valueKey) : item;
+    return compare(itemValue, value);
+  });
+  if (isEmpty(value) && foundItem) {
+    return labelKey ? get(foundItem, labelKey) : void 0;
+  }
+  if (isEmpty(value)) {
+    return void 0;
+  }
+  const source = foundItem ?? value;
+  if (source === null || source === void 0) {
+    return void 0;
+  }
+  if (typeof source === "object") {
+    return labelKey ? get(source, labelKey) : void 0;
+  }
+  return String(source);
+}
 export function isArrayOfArray(item) {
   return Array.isArray(item[0]);
 }
@@ -74,34 +124,16 @@ export function mergeClasses(appConfigClass, propClass) {
   ].filter(Boolean);
 }
 export function getSlotChildrenText(children) {
-  if (!children) return "";
-  if (typeof children === "string") return children;
-  if (Array.isArray(children)) {
-    return children.map(getSlotChildrenText).join("");
-  }
-  if (typeof children === "object") {
-    if (children.children) {
-      return getSlotChildrenText(children.children);
-    }
-    if (typeof children.default === "function") {
-      return getSlotChildrenText(children.default());
-    }
-  }
-  return "";
+  return children.map((node) => {
+    if (!node.children || typeof node.children === "string") return node.children || "";
+    else if (Array.isArray(node.children)) return getSlotChildrenText(node.children);
+    else if (node.children.default) return getSlotChildrenText(node.children.default());
+  }).join("");
 }
 export function transformUI(ui, uiProp) {
-  const result = {};
-  for (const key in ui) {
-    const uiValue = ui[key];
-    const classValue = normalizeClass(uiProp?.[key]);
-    result[key] = typeof uiValue === "function" ? uiValue({ class: classValue }) : uiValue;
-  }
-  return result;
-}
-function normalizeClass(value) {
-  if (typeof value === "string") return value;
-  if (Array.isArray(value)) return value.filter(Boolean).join(" ");
-  if (typeof value === "number" || typeof value === "boolean") return String(value);
-  return void 0;
+  return Object.entries(ui).reduce((acc, [key, value]) => {
+    acc[key] = typeof value === "function" ? value({ class: uiProp?.[key] }) : value;
+    return acc;
+  }, uiProp || {});
 }
 export * from "./content.js";

package/dist/runtime/utils/tv.d.ts

@@ -1 +1 @@
-export declare const tv: import("tailwind-variants").CreateTV;
+export declare const tv: import("tailwind-variants").TV;

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

@@ -0,0 +1,6 @@
+import type { IconProps as NuxtIconProps } from '../../types';
+export interface IconProps {
+    name: NuxtIconProps['name'];
+}
+declare const _default: import("vue").DefineComponent<IconProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<IconProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/runtime/vue/components/Icon.vue

@@ -5,10 +5,11 @@
 <script setup>
 import { Icon as IconifyIcon } from "@iconify/vue";
 defineProps({
-  name: { type: String, required: true }
+  name: { type: [String, Object], required: true }
 });
 </script>
 
 <template>
-  <IconifyIcon :icon="name.replace(/^i-/, '')" />
+  <IconifyIcon v-if="typeof name === 'string'" :icon="name.replace(/^i-/, '')" />
+  <component :is="name" v-else />
 </template>

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

@@ -1,5 +1,6 @@
+import type { IconProps as NuxtIconProps } from '../../types';
 export interface IconProps {
-    name: string;
+    name: NuxtIconProps['name'];
 }
-declare const _default: import("vue").DefineComponent<IconProps, void, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<IconProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: import("vue").DefineComponent<IconProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<IconProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 export default _default;

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

@@ -0,0 +1,93 @@
+import type { ButtonHTMLAttributes } from 'vue';
+import type { RouterLinkProps, RouteLocationRaw } from 'vue-router';
+interface NuxtLinkProps extends Omit<RouterLinkProps, 'to'> {
+    /**
+     * Route Location the link should navigate to when clicked on.
+     */
+    to?: RouteLocationRaw;
+    /**
+     * An alias for `to`. If used with `to`, `href` will be ignored
+     */
+    href?: NuxtLinkProps['to'];
+    /**
+     * Forces the link to be considered as external (true) or internal (false). This is helpful to handle edge-cases
+     */
+    external?: boolean;
+    /**
+     * Where to display the linked URL, as the name for a browsing context.
+     */
+    target?: '_blank' | '_parent' | '_self' | '_top' | (string & {}) | null;
+    /**
+     * A rel attribute value to apply on the link. Defaults to "noopener noreferrer" for external links.
+     */
+    rel?: 'noopener' | 'noreferrer' | 'nofollow' | 'sponsored' | 'ugc' | (string & {}) | null;
+    /**
+     * If set to true, no rel attribute will be added to the link
+     */
+    noRel?: boolean;
+    /**
+     * A class to apply to links that have been prefetched.
+     */
+    prefetchedClass?: string;
+    /**
+     * When enabled will prefetch middleware, layouts and payloads of links in the viewport.
+     */
+    prefetch?: boolean;
+    /**
+     * Allows controlling when to prefetch links. By default, prefetch is triggered only on visibility.
+     */
+    prefetchOn?: 'visibility' | 'interaction' | Partial<{
+        visibility: boolean;
+        interaction: boolean;
+    }>;
+    /**
+     * Escape hatch to disable `prefetch` attribute.
+     */
+    noPrefetch?: boolean;
+}
+export interface LinkProps extends NuxtLinkProps {
+    /**
+     * The element or component this component should render as when not a link.
+     * @defaultValue 'button'
+     */
+    as?: any;
+    /**
+     * The type of the button when not a link.
+     * @defaultValue 'button'
+     */
+    type?: ButtonHTMLAttributes['type'];
+    disabled?: boolean;
+    /** Force the link to be active independent of the current route. */
+    active?: boolean;
+    /** Will only be active if the current route is an exact match. */
+    exact?: boolean;
+    /** Will only be active if the current route query is an exact match. */
+    exactQuery?: boolean | 'partial';
+    /** Will only be active if the current route hash is an exact match. */
+    exactHash?: boolean;
+    /** The class to apply when the link is inactive. */
+    inactiveClass?: string;
+    custom?: boolean;
+    /** When `true`, only styles from `class`, `activeClass`, and `inactiveClass` will be applied. */
+    raw?: boolean;
+    class?: any;
+}
+export interface LinkSlots {
+    default(props: {
+        active: boolean;
+    }): any;
+}
+declare const _default: __VLS_WithSlots<import("vue").DefineComponent<LinkProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<LinkProps> & Readonly<{}>, {
+    type: "reset" | "submit" | "button";
+    as: any;
+    activeClass: string;
+    ariaCurrentValue: "page" | "step" | "location" | "date" | "time" | "true" | "false";
+    active: boolean;
+    inactiveClass: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, LinkSlots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -77,7 +77,7 @@ export interface LinkSlots {
         active: boolean;
     }): any;
 }
-declare const _default: __VLS_WithSlots<import("vue").DefineComponent<LinkProps, void, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<LinkProps> & Readonly<{}>, {
+declare const _default: __VLS_WithSlots<import("vue").DefineComponent<LinkProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<LinkProps> & Readonly<{}>, {
     type: "reset" | "submit" | "button";
     as: any;
     activeClass: string;

package/dist/runtime/vue/components/color-mode/ColorModeButton.d.vue.ts

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

package/dist/runtime/vue/components/color-mode/ColorModeButton.vue

@@ -5,12 +5,13 @@
 <script setup>
 import { computed } from "vue";
 import { useAppConfig, useColorMode } from "#imports";
-import { useLocalePro } from "../../../composables/useLocalePro";
+import { useLocale } from "../../../composables/useLocale";
+import UButton from "../../../components/Button.vue";
 defineProps({
   color: { type: null, required: false, default: "neutral" },
   variant: { type: null, required: false, default: "ghost" }
 });
-const { t } = useLocalePro();
+const { t } = useLocale();
 const colorMode = useColorMode();
 const appConfig = useAppConfig();
 const isDark = computed({

package/dist/runtime/vue/components/color-mode/ColorModeButton.vue.d.ts

@@ -9,30 +9,8 @@ export interface ColorModeButtonProps extends /** @vue-ignore */ Pick<ButtonProp
      */
     variant?: ButtonProps['variant'];
 }
-declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
-    color: {
-        type: null;
-        required: false;
-        default: string;
-    };
-    variant: {
-        type: null;
-        required: false;
-        default: string;
-    };
-}>, void, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
-    color: {
-        type: null;
-        required: false;
-        default: string;
-    };
-    variant: {
-        type: null;
-        required: false;
-        default: string;
-    };
-}>> & Readonly<{}>, {
-    color: any;
-    variant: any;
-}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: import("vue").DefineComponent<ColorModeButtonProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ColorModeButtonProps> & Readonly<{}>, {
+    color: "error" | "primary" | "secondary" | "success" | "info" | "warning" | "neutral";
+    variant: "link" | "solid" | "outline" | "soft" | "subtle" | "ghost";
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 export default _default;

package/dist/runtime/vue/components/color-mode/ColorModeSelect.d.vue.ts

@@ -0,0 +1,5 @@
+import type { SelectMenuProps } from '../../../types';
+export interface ColorModeSelectProps extends /** @vue-ignore */ Pick<SelectMenuProps<any>, 'color' | 'variant' | 'size' | 'trailingIcon' | 'selectedIcon' | 'content' | 'arrow' | 'portal' | 'disabled' | 'ui'> {
+}
+declare const _default: import("vue").DefineComponent<ColorModeSelectProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ColorModeSelectProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/runtime/vue/components/color-mode/ColorModeSelect.vue

@@ -5,10 +5,11 @@
 <script setup>
 import { computed } from "vue";
 import { useAppConfig, useColorMode } from "#imports";
-import { useLocalePro } from "../../../composables/useLocalePro";
+import { useLocale } from "../../../composables/useLocale";
+import USelectMenu from "../../../components/SelectMenu.vue";
 defineOptions({ inheritAttrs: false });
 defineProps({});
-const { t } = useLocalePro();
+const { t } = useLocale();
 const colorMode = useColorMode();
 const appConfig = useAppConfig();
 const items = computed(() => [
@@ -21,7 +22,7 @@ const preference = computed({
     return items.value.find((option) => option.value === colorMode.preference) || items.value[0];
   },
   set(option) {
-    colorMode.preference = option?.value || "system";
+    colorMode.preference = option.value;
   }
 });
 </script>

package/dist/runtime/vue/components/color-mode/ColorModeSelect.vue.d.ts

@@ -1,5 +1,5 @@
 import type { SelectMenuProps } from '../../../types';
 export interface ColorModeSelectProps extends /** @vue-ignore */ Pick<SelectMenuProps<any>, 'color' | 'variant' | 'size' | 'trailingIcon' | 'selectedIcon' | 'content' | 'arrow' | 'portal' | 'disabled' | 'ui'> {
 }
-declare const _default: import("vue").DefineComponent<{}, void, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: import("vue").DefineComponent<ColorModeSelectProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ColorModeSelectProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 export default _default;

package/dist/runtime/vue/components/color-mode/ColorModeSwitch.d.vue.ts

@@ -0,0 +1,5 @@
+import type { SwitchProps } from '../../../types';
+export interface ColorModeSwitchProps extends /** @vue-ignore */ Pick<SwitchProps, 'as' | 'color' | 'size' | 'disabled' | 'ui'> {
+}
+declare const _default: import("vue").DefineComponent<ColorModeSwitchProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ColorModeSwitchProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/runtime/vue/components/color-mode/ColorModeSwitch.vue

@@ -5,10 +5,11 @@
 <script setup>
 import { computed } from "vue";
 import { useAppConfig, useColorMode } from "#imports";
-import { useLocalePro } from "../../../composables/useLocalePro";
+import { useLocale } from "../../../composables/useLocale";
+import USwitch from "../../../components/Switch.vue";
 defineOptions({ inheritAttrs: false });
 defineProps({});
-const { t } = useLocalePro();
+const { t } = useLocale();
 const colorMode = useColorMode();
 const appConfig = useAppConfig();
 const isDark = computed({

package/dist/runtime/vue/components/color-mode/ColorModeSwitch.vue.d.ts

@@ -1,5 +1,5 @@
 import type { SwitchProps } from '../../../types';
 export interface ColorModeSwitchProps extends /** @vue-ignore */ Pick<SwitchProps, 'as' | 'color' | 'size' | 'disabled' | 'ui'> {
 }
-declare const _default: import("vue").DefineComponent<{}, void, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: import("vue").DefineComponent<ColorModeSwitchProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ColorModeSwitchProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 export default _default;

package/dist/runtime/vue/stubs.d.ts

@@ -12,7 +12,7 @@ export declare const useColorMode: () => {
     preference?: undefined;
     readonly value?: undefined;
 } | {
-    preference: "system" | "light" | "dark";
+    preference: "dark" | "light" | "system";
     readonly value: import("@vueuse/core").BasicColorMode;
     forced: boolean;
 };