@nuxt/ui 2.18.4 → 3.0.0-alpha.0

package/dist/runtime/types/index.js

@@ -1,31 +1,42 @@
-export * from "./accordion";
-export * from "./alert";
-export * from "./avatar";
-export * from "./badge";
-export * from "./breadcrumb";
-export * from "./button";
-export * from "./chip";
-export * from "./clipboard";
-export * from "./command-palette";
-export * from "./divider";
-export * from "./dropdown";
-export * from "./form-group";
-export * from "./form";
-export * from "./horizontal-navigation";
-export * from "./input";
-export * from "./kbd";
-export * from "./link";
-export * from "./meter";
-export * from "./modal";
-export * from "./slideover";
-export * from "./notification";
-export * from "./popper";
-export * from "./progress";
-export * from "./range";
-export * from "./select";
-export * from "./tabs";
-export * from "./textarea";
-export * from "./toggle";
-export * from "./tooltip";
-export * from "./vertical-navigation";
-export * from "./utils";
+export * from "../components/Accordion.vue";
+export * from "../components/Alert.vue";
+export * from "../components/App.vue";
+export * from "../components/Avatar.vue";
+export * from "../components/AvatarGroup.vue";
+export * from "../components/Badge.vue";
+export * from "../components/Breadcrumb.vue";
+export * from "../components/Button.vue";
+export * from "../components/Card.vue";
+export * from "../components/Checkbox.vue";
+export * from "../components/Chip.vue";
+export * from "../components/Collapsible.vue";
+export * from "../components/CommandPalette.vue";
+export * from "../components/Container.vue";
+export * from "../components/ContextMenu.vue";
+export * from "../components/Drawer.vue";
+export * from "../components/DropdownMenu.vue";
+export * from "../components/Form.vue";
+export * from "../components/FormField.vue";
+export * from "../components/Input.vue";
+export * from "../components/InputMenu.vue";
+export * from "../components/Kbd.vue";
+export * from "../components/Link.vue";
+export * from "../components/Modal.vue";
+export * from "../components/NavigationMenu.vue";
+export * from "../components/Pagination.vue";
+export * from "../components/Popover.vue";
+export * from "../components/Progress.vue";
+export * from "../components/RadioGroup.vue";
+export * from "../components/Select.vue";
+export * from "../components/SelectMenu.vue";
+export * from "../components/Separator.vue";
+export * from "../components/Skeleton.vue";
+export * from "../components/Slideover.vue";
+export * from "../components/Slider.vue";
+export * from "../components/Switch.vue";
+export * from "../components/Tabs.vue";
+export * from "../components/Textarea.vue";
+export * from "../components/Toast.vue";
+export * from "../components/Toaster.vue";
+export * from "../components/Tooltip.vue";
+export * from "./form.js";

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

@@ -1,36 +1,17 @@
-export type Strategy = 'merge' | 'override'
-
 export interface TightMap<O = any> {
-  [key: string]: TightMap | O
+    [key: string]: TightMap | O;
 }
-
 export type DeepPartial<T, O = any> = {
-  [P in keyof T]?: T[P] extends object
-    ? DeepPartial<T[P], O>
-    : T[P];
+    [P in keyof T]?: T[P] extends object ? DeepPartial<T[P], O> : T[P];
 } & {
-  [key: string]: O | TightMap<O>
-}
-
-export type NestedKeyOf<ObjectType extends Record<string, any>> = {
-  [Key in keyof ObjectType]: ObjectType[Key] extends Record<string, any>
-  ? NestedKeyOf<ObjectType[Key]>
-  : Key
-}[keyof ObjectType]
-
-type DeepKey<T, Keys extends string[]> =
-  Keys extends [infer First, ...infer Rest]
-    ? First extends keyof T
-      ? Rest extends string[]
-        ? DeepKey<T[First], Rest>
-        : never
-      : never
-    : T
-
-export type ExtractDeepKey<T, Path extends string[]> = DeepKey<T, Path> extends infer Result
-  ? Result extends Record<string, any> ? keyof Result : never
-  : never
-
-export type ExtractDeepObject<T, Path extends string[]> = DeepKey<T, Path> extends infer Result
-  ? Result extends Record<string, any> ? Result : never
-  : never
+    [key: string]: O | TightMap<O>;
+};
+export type DynamicSlots<T extends {
+    slot?: string;
+}, SlotProps, Slot = T['slot']> = Record<string, SlotProps> & (Slot extends string ? Record<Slot, SlotProps> : Record<string, never>);
+export type GetObjectField<MaybeObject, Key extends string> = MaybeObject extends Record<string, any> ? MaybeObject[Key] : never;
+export type AcceptableValue = string | number | boolean | Record<string, any>;
+export type ArrayOrWrapped<T> = T extends any[] ? T : Array<T>;
+export type PartialString<T> = {
+    [K in keyof T]?: string;
+};

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

@@ -0,0 +1,15 @@
+import type { ZodSchema } from 'zod';
+import type { ValidationError as JoiError, Schema as JoiSchema } from 'joi';
+import type { ObjectSchema as YupObjectSchema, ValidationError as YupError } from 'yup';
+import type { GenericSchema as ValibotSchema, GenericSchemaAsync as ValibotSchemaAsync, SafeParser as ValibotSafeParser, SafeParserAsync as ValibotSafeParserAsync } from 'valibot';
+import type { FormError } from '../types/form.js';
+export declare function isYupSchema(schema: any): schema is YupObjectSchema<any>;
+export declare function isYupError(error: any): error is YupError;
+export declare function getYupErrors(state: any, schema: YupObjectSchema<any>): Promise<FormError[]>;
+export declare function isZodSchema(schema: any): schema is ZodSchema;
+export declare function getZodErrors(state: any, schema: ZodSchema): Promise<FormError[]>;
+export declare function isJoiSchema(schema: any): schema is JoiSchema;
+export declare function isJoiError(error: any): error is JoiError;
+export declare function getJoiErrors(state: any, schema: JoiSchema): Promise<FormError[]>;
+export declare function isValibotSchema(schema: any): schema is ValibotSchema | ValibotSchemaAsync | ValibotSafeParser<any, any> | ValibotSafeParserAsync<any, any>;
+export declare function getValibotError(state: any, schema: ValibotSchema | ValibotSchemaAsync | ValibotSafeParser<any, any> | ValibotSafeParserAsync<any, any>): Promise<FormError[]>;

package/dist/runtime/utils/form.js

@@ -0,0 +1,66 @@
+export function isYupSchema(schema) {
+  return schema.validate && schema.__isYupSchema__;
+}
+export function isYupError(error) {
+  return error.inner !== void 0;
+}
+export async function getYupErrors(state, schema) {
+  try {
+    await schema.validate(state, { abortEarly: false });
+    return [];
+  } catch (error) {
+    if (isYupError(error)) {
+      return error.inner.map((issue) => ({
+        name: issue.path ?? "",
+        message: issue.message
+      }));
+    } else {
+      throw error;
+    }
+  }
+}
+export function isZodSchema(schema) {
+  return schema.parse !== void 0;
+}
+export async function getZodErrors(state, schema) {
+  const result = await schema.safeParseAsync(state);
+  if (result.success === false) {
+    return result.error.issues.map((issue) => ({
+      name: issue.path.join("."),
+      message: issue.message
+    }));
+  }
+  return [];
+}
+export function isJoiSchema(schema) {
+  return schema.validateAsync !== void 0 && schema.id !== void 0;
+}
+export function isJoiError(error) {
+  return error.isJoi === true;
+}
+export async function getJoiErrors(state, schema) {
+  try {
+    await schema.validateAsync(state, { abortEarly: false });
+    return [];
+  } catch (error) {
+    if (isJoiError(error)) {
+      return error.details.map((detail) => ({
+        name: detail.path.join("."),
+        message: detail.message
+      }));
+    } else {
+      throw error;
+    }
+  }
+}
+export function isValibotSchema(schema) {
+  return "_run" in schema || typeof schema === "function" && "schema" in schema;
+}
+export async function getValibotError(state, schema) {
+  const result = await ("_run" in schema ? schema._run({ typed: false, value: state }, {}) : schema(state));
+  return result.issues?.map((issue) => ({
+    // We know that the key for a form schema is always a string or a number
+    name: issue.path?.map((item) => item.key).join(".") || "",
+    message: issue.message
+  })) || [];
+}

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

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

package/dist/runtime/utils/fuse.js

@@ -0,0 +1,63 @@
+function truncateHTMLFromStart(html, maxLength) {
+  let truncated = "";
+  let totalLength = 0;
+  let insideTag = false;
+  for (let i = html.length - 1; i >= 0; i--) {
+    if (html[i] === ">") {
+      insideTag = true;
+    } else if (html[i] === "<") {
+      insideTag = false;
+      truncated = html[i] + truncated;
+      continue;
+    }
+    if (!insideTag) {
+      totalLength++;
+    }
+    if (totalLength <= maxLength) {
+      truncated = html[i] + truncated;
+    } else {
+      truncated = "..." + truncated;
+      break;
+    }
+  }
+  return truncated;
+}
+export function highlight(item, searchTerm, forceKey, omitKeys) {
+  function generateHighlightedText(value, indices = []) {
+    value = value || "";
+    let content = "";
+    let nextUnhighlightedRegionStartingIndex = 0;
+    indices.forEach((region) => {
+      if (region.length === 2 && region[0] === region[1]) {
+        return;
+      }
+      const lastIndiceNextIndex = region[1] + 1;
+      const isMatched = lastIndiceNextIndex - region[0] >= searchTerm.length;
+      content += [
+        value.substring(nextUnhighlightedRegionStartingIndex, region[0]),
+        isMatched && `<mark>`,
+        value.substring(region[0], lastIndiceNextIndex),
+        isMatched && "</mark>"
+      ].filter(Boolean).join("");
+      nextUnhighlightedRegionStartingIndex = lastIndiceNextIndex;
+    });
+    content += value.substring(nextUnhighlightedRegionStartingIndex);
+    const markIndex = content.indexOf("<mark>");
+    if (markIndex !== -1) {
+      content = truncateHTMLFromStart(content, content.length - markIndex);
+    }
+    return content;
+  }
+  if (!item.matches?.length) {
+    return;
+  }
+  for (const match of item.matches) {
+    if (forceKey && match.key !== forceKey) {
+      continue;
+    }
+    if (omitKeys?.includes(match.key)) {
+      continue;
+    }
+    return generateHighlightedText(match.value, match.indices);
+  }
+}

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

@@ -1,11 +1,5 @@
-import type { Strategy } from '../types/index.js';
-export declare function mergeConfig<T>(strategy: Strategy, ...configs: any[]): T;
-export declare function hexToRgb(hex: string): string;
-export declare function getSlotsChildren(slots: any): any;
-/**
- * "123-foo" will be parsed to 123
- * This is used for the .number modifier in v-model
- */
+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>, 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 * from './lodash.js';
-export * from './link.js';

package/dist/runtime/utils/index.js

@@ -1,67 +1,47 @@
-import { defu, createDefu } from "defu";
-import { extendTailwindMerge } from "tailwind-merge";
-const customTwMerge = extendTailwindMerge({
-  extend: {
-    classGroups: {
-      icons: [(classPart) => /^i-/.test(classPart)]
-    }
-  }
-});
-const defuTwMerge = createDefu((obj, key, value, namespace) => {
-  if (namespace === "default" || namespace.startsWith("default.")) {
-    return false;
-  }
-  if (namespace === "popper" || namespace.startsWith("popper.")) {
-    return false;
-  }
-  if (namespace.endsWith("avatar") && key === "size") {
-    return false;
-  }
-  if (namespace.endsWith("chip") && key === "size") {
-    return false;
-  }
-  if (namespace.endsWith("badge") && key === "size" || key === "color" || key === "variant") {
-    return false;
+export function pick(data, keys) {
+  const result = {};
+  for (const key of keys) {
+    result[key] = data[key];
   }
-  if (typeof obj[key] === "string" && typeof value === "string" && obj[key] && value) {
-    obj[key] = customTwMerge(obj[key], value);
-    return true;
-  }
-});
-export function mergeConfig(strategy, ...configs) {
-  if (strategy === "override") {
-    return defu({}, ...configs);
-  }
-  return defuTwMerge({}, ...configs);
+  return result;
 }
-export function hexToRgb(hex) {
-  const shorthandRegex = /^#?([a-f\d])([a-f\d])([a-f\d])$/i;
-  hex = hex.replace(shorthandRegex, function(_, r, g, b) {
-    return r + r + g + g + b + b;
-  });
-  const result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
-  return result ? `${parseInt(result[1], 16)} ${parseInt(result[2], 16)} ${parseInt(result[3], 16)}` : null;
+export function omit(data, keys) {
+  const result = { ...data };
+  for (const key of keys) {
+    delete result[key];
+  }
+  return result;
 }
-export function getSlotsChildren(slots) {
-  let children = slots.default?.();
-  if (children?.length) {
-    children = children.flatMap((c) => {
-      if (typeof c.type === "symbol") {
-        if (typeof c.children === "string") {
-          return;
-        }
-        return c.children;
-      } else if (c.type.name === "ContentSlot") {
-        return c.ctx.slots.default?.();
-      }
-      return c;
-    }).filter(Boolean);
+export function get(object, path, defaultValue) {
+  if (typeof path === "string") {
+    path = path.split(".").map((key) => {
+      const numKey = Number(key);
+      return Number.isNaN(numKey) ? key : numKey;
+    });
+  }
+  let result = object;
+  for (const key of path) {
+    if (result === void 0 || result === null) {
+      return defaultValue;
+    }
+    result = result[key];
   }
-  return children || [];
+  return result !== void 0 ? result : defaultValue;
+}
+export function set(object, path, value) {
+  if (typeof path === "string") {
+    path = path.split(".").map((key) => {
+      const numKey = Number(key);
+      return Number.isNaN(numKey) ? key : numKey;
+    });
+  }
+  path.reduce((acc, key, i) => {
+    if (acc[key] === void 0) acc[key] = {};
+    if (i === path.length - 1) acc[key] = value;
+    return acc[key];
+  }, object);
 }
 export function looseToNumber(val) {
-  const n = parseFloat(val);
-  return isNaN(n) ? val : n;
+  const n = Number.parseFloat(val);
+  return Number.isNaN(n) ? val : n;
 }
-export * from "./lodash.js";
-export * from "./link.js";

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

@@ -1,72 +1,59 @@
-import type { PropType } from 'vue';
-import type { RouteLocationRaw } from '#vue-router';
-import type { NuxtLinkProps } from '#app';
-export declare const nuxtLinkProps: {
-    readonly to: {
-        readonly type: PropType<RouteLocationRaw>;
-        readonly default: any;
-        readonly required: false;
-    };
-    readonly href: {
-        readonly type: PropType<RouteLocationRaw>;
-        readonly default: any;
-        readonly required: false;
-    };
-    readonly target: {
-        readonly type: PropType<NuxtLinkProps["target"]>;
-        readonly default: any;
-        readonly required: false;
-    };
-    readonly rel: {
-        readonly type: PropType<any>;
-        readonly default: any;
-        readonly required: false;
-    };
-    readonly noRel: {
-        readonly type: PropType<NuxtLinkProps["noRel"]>;
-        readonly default: any;
-        readonly required: false;
-    };
-    readonly prefetch: {
-        readonly type: PropType<NuxtLinkProps["prefetch"]>;
-        readonly default: any;
-        readonly required: false;
-    };
-    readonly noPrefetch: {
-        readonly type: PropType<NuxtLinkProps["noPrefetch"]>;
-        readonly default: any;
-        readonly required: false;
-    };
-    readonly activeClass: {
-        readonly type: PropType<NuxtLinkProps["activeClass"]>;
-        readonly default: any;
-        readonly required: false;
-    };
-    readonly exactActiveClass: {
-        readonly type: PropType<NuxtLinkProps["exactActiveClass"]>;
-        readonly default: any;
-        readonly required: false;
-    };
-    readonly prefetchedClass: {
-        readonly type: PropType<NuxtLinkProps["prefetchedClass"]>;
-        readonly default: any;
-        readonly required: false;
-    };
-    readonly replace: {
-        readonly type: PropType<NuxtLinkProps["replace"]>;
-        readonly default: any;
-        readonly required: false;
-    };
-    readonly ariaCurrentValue: {
-        readonly type: PropType<NuxtLinkProps["ariaCurrentValue"]>;
-        readonly default: any;
-        readonly required: false;
-    };
-    readonly external: {
-        readonly type: PropType<NuxtLinkProps["external"]>;
-        readonly default: any;
-        readonly required: false;
-    };
+import type { LinkProps } from '../types.js';
+export declare function pickLinkProps(link: LinkProps & {
+    ariaLabel?: string;
+}): {
+    type?: import("vue").ButtonHTMLAttributes["type"];
+    as?: any;
+    target?: ("_blank" | "_parent" | "_self" | "_top" | (string & {}) | null) | undefined;
+    to?: string | {
+        name?: import("vue-router").RouteRecordNameGeneric;
+        params?: import("vue-router").RouteParamsRawGeneric | undefined;
+        path?: undefined;
+        query?: import("vue-router").LocationQueryRaw | undefined;
+        hash?: string | undefined;
+        replace?: boolean | undefined;
+        force?: boolean | undefined;
+        state?: import("vue-router").HistoryState | undefined;
+    } | {
+        path: string;
+        query?: import("vue-router").LocationQueryRaw | undefined;
+        hash?: string | undefined;
+        replace?: boolean | undefined;
+        force?: boolean | undefined;
+        state?: import("vue-router").HistoryState | undefined;
+    } | undefined;
+    activeClass?: string | undefined;
+    exactActiveClass?: string | undefined;
+    ariaCurrentValue?: ("page" | "step" | "location" | "date" | "time" | "true" | "false") | undefined;
+    replace?: boolean | undefined;
+    disabled?: boolean | undefined;
+    active?: boolean | undefined;
+    exact?: boolean | undefined;
+    exactQuery?: boolean | undefined;
+    exactHash?: boolean | undefined;
+    inactiveClass?: string | undefined;
+    href?: string | {
+        name?: import("vue-router").RouteRecordNameGeneric;
+        params?: import("vue-router").RouteParamsRawGeneric | undefined;
+        path?: undefined;
+        query?: import("vue-router").LocationQueryRaw | undefined;
+        hash?: string | undefined;
+        replace?: boolean | undefined;
+        force?: boolean | undefined;
+        state?: import("vue-router").HistoryState | undefined;
+    } | {
+        path: string;
+        query?: import("vue-router").LocationQueryRaw | undefined;
+        hash?: string | undefined;
+        replace?: boolean | undefined;
+        force?: boolean | undefined;
+        state?: import("vue-router").HistoryState | undefined;
+    } | undefined;
+    external?: boolean | undefined;
+    rel?: ("noopener" | "noreferrer" | "nofollow" | "sponsored" | "ugc" | (string & {}) | null) | undefined;
+    noRel?: boolean | undefined;
+    prefetchedClass?: string | undefined;
+    prefetch?: boolean | undefined;
+    noPrefetch?: boolean | undefined;
+    ariaLabel?: string | undefined;
 };
-export declare const getNuxtLinkProps: (props: any) => {};
-export declare const getULinkProps: (props: any) => {};