@nuxt/ui 3.3.2 → 4.0.0-alpha.0

package/dist/runtime/components/content/ContentSearch.vue

@@ -0,0 +1,174 @@
+<script>
+import theme from "#build/ui/content/content-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 } from "#imports";
+import { useContentSearch } from "../../composables/useContentSearch";
+import { useLocale } from "../../composables/useLocale";
+import { omit, transformUI } from "../../utils";
+import { tv } from "../../utils/tv";
+import UModal from "../Modal.vue";
+import UCommandPalette from "../CommandPalette.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" },
+  links: { type: Array, required: false },
+  navigation: { type: Array, required: false },
+  groups: { type: Array, required: false },
+  files: { 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 searchTerm = defineModel("searchTerm", { type: String, ...{ default: "" } });
+const { t } = useLocale();
+const { open } = useContentSearch();
+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: {
+    includeMatches: true
+  }
+}));
+const ui = computed(() => tv({ extend: tv(theme), ...appConfig.ui?.contentSearch || {} })());
+function mapLinksItems(links) {
+  return links.flatMap((link) => [{
+    ...link,
+    suffix: link.description,
+    icon: link.icon || appConfig.ui.icons.file
+  }, ...link.children?.map((child) => ({
+    ...child,
+    prefix: link.label + " >",
+    suffix: child.description,
+    icon: child.icon || link.icon || appConfig.ui.icons.file
+  })) || []]);
+}
+function mapNavigationItems(children, parent) {
+  return children.flatMap((link) => {
+    if (link.children?.length) {
+      return mapNavigationItems(link.children, link);
+    }
+    return props.files?.filter((file) => file.id === link.path || file.id.startsWith(`${link.path}#`))?.map((file) => mapFile(file, link, parent)) || [];
+  });
+}
+function mapFile(file, link, parent) {
+  const prefix = [...new Set([parent?.title, ...file.titles].filter(Boolean))];
+  return {
+    prefix: prefix?.length ? prefix.join(" > ") + " >" : void 0,
+    label: file.id === link.path ? link.title : file.title,
+    suffix: file.content.replaceAll("<", "&lt;").replaceAll(">", "&gt;"),
+    to: file.id,
+    icon: link.icon || parent?.icon || (file.level > 1 ? appConfig.ui.icons.hash : appConfig.ui.icons.file),
+    level: file.level
+  };
+}
+const groups = computed(() => {
+  const groups2 = [];
+  if (props.links?.length) {
+    groups2.push({ id: "links", label: t("contentSearch.links"), items: mapLinksItems(props.links) });
+  }
+  if (props.navigation?.length) {
+    if (props.navigation.some((link) => !!link.children?.length)) {
+      groups2.push(...props.navigation.map((group) => ({ id: group.path, label: group.title, items: mapNavigationItems(group.children || []), postFilter })));
+    } else {
+      groups2.push({ id: "docs", items: mapNavigationItems(props.navigation), postFilter });
+    }
+  }
+  groups2.push(...props.groups || []);
+  if (props.colorMode && !colorMode?.forced) {
+    groups2.push({
+      id: "theme",
+      label: t("contentSearch.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 postFilter(query, items) {
+  if (!query) {
+    return items?.filter((item) => item.level === 1);
+  }
+  return items;
+}
+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('contentSearch.title')"
+    :description="t('contentSearch.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/content/ContentSearch.vue.d.ts

@@ -0,0 +1,114 @@
+import type { ContentNavigationItem } from '@nuxt/content';
+import type { AppConfig } from '@nuxt/schema';
+import type { UseFuseOptions } from '@vueuse/integrations/useFuse';
+import theme from '#build/ui/content/content-search';
+import type { ButtonProps, InputProps, LinkProps, ModalProps, CommandPaletteProps, CommandPaletteSlots, CommandPaletteGroup, CommandPaletteItem } from '../../types';
+import type { ComponentConfig } from '../../types/tv';
+type ContentSearch = ComponentConfig<typeof theme, AppConfig, 'contentSearch'>;
+export interface ContentSearchLink extends Omit<LinkProps, 'custom'> {
+    label?: string;
+    description?: string;
+    /**
+     * @IconifyIcon
+     */
+    icon?: string;
+    children?: ContentSearchLink[];
+}
+export interface ContentSearchFile {
+    id: string;
+    title: string;
+    titles: string[];
+    level: number;
+    content: string;
+}
+export interface ContentSearchItem extends Omit<LinkProps, 'custom'>, CommandPaletteItem {
+    level?: number;
+    /**
+     * @IconifyIcon
+     */
+    icon?: string;
+}
+export interface ContentSearchProps<T extends ContentSearchLink = ContentSearchLink> 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;
+    /** Links group displayed as the first group in the command palette. */
+    links?: T[];
+    navigation?: ContentNavigationItem[];
+    /** Custom groups displayed between navigation and color mode group. */
+    groups?: CommandPaletteGroup<ContentSearchItem>[];
+    files?: ContentSearchFile[];
+    /**
+     * Options for [useFuse](https://vueuse.org/integrations/useFuse) passed to the [CommandPalette](https://ui.nuxt.com/docs/components/command-palette).
+     * @defaultValue { fuseOptions: { includeMatches: true } }
+     */
+    fuse?: UseFuseOptions<T>;
+    /**
+     * When `true`, the theme command will be added to the groups.
+     * @defaultValue true
+     */
+    colorMode?: boolean;
+    class?: any;
+    ui?: ContentSearch['slots'] & CommandPaletteProps<CommandPaletteGroup<ContentSearchItem>, ContentSearchItem>['ui'];
+}
+export type ContentSearchSlots = CommandPaletteSlots<CommandPaletteGroup<ContentSearchItem>, ContentSearchItem> & {
+    content(props?: {}): any;
+};
+declare const _default: <T extends ContentSearchLink>(__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:searchTerm"?: ((value: string) => any) | undefined;
+    } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>, "onUpdate:searchTerm"> & (ContentSearchProps<T> & {
+        searchTerm?: string;
+    }) & Partial<{}>> & import("vue").PublicProps;
+    expose(exposed: import("vue").ShallowUnwrapRef<{
+        commandPaletteRef: Readonly<import("vue").ShallowRef<import("vue").ShallowUnwrapRef<{}> | null>>;
+    }>): void;
+    attrs: any;
+    slots: ContentSearchSlots;
+    emit: (evt: "update:searchTerm", value: string) => 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/content/ContentSearchButton.vue

@@ -0,0 +1,81 @@
+<script>
+import theme from "#build/ui/content/content-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 { useContentSearch } from "../../composables/useContentSearch";
+import { useLocale } from "../../composables/useLocale";
+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: true },
+  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 { open } = useContentSearch();
+const appConfig = useAppConfig();
+const ui = computed(() => tv({ extend: tv(theme), ...appConfig.ui?.contentSearchButton || {} })());
+</script>
+
+<template>
+  <DefineButtonTemplate>
+    <UButton
+      :icon="icon || appConfig.ui.icons.search"
+      :label="label || t('contentSearchButton.label')"
+      :variant="variant || (collapsed ? 'ghost' : 'outline')"
+      v-bind="{
+  ...rootProps,
+  ...collapsed ? {
+    'square': true,
+    'label': void 0,
+    'aria-label': label || t('contentSearchButton.label')
+  } : {},
+  ...$attrs
+}"
+      :class="ui.base({ class: [props.ui?.base, props.class] })"
+      :ui="transformUI(ui, props.ui)"
+      @click="open = true"
+    >
+      <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('contentSearchButton.label')" v-bind="tooltipProps">
+    <ReuseButtonTemplate />
+  </UTooltip>
+  <ReuseButtonTemplate v-else />
+</template>

package/dist/runtime/components/content/ContentSearchButton.vue.d.ts

@@ -0,0 +1,59 @@
+import type { AppConfig } from '@nuxt/schema';
+import theme from '#build/ui/content/content-search-button';
+import type { ButtonProps, ButtonSlots, KbdProps, TooltipProps } from '../../types';
+import type { ComponentConfig } from '../../types/tv';
+type ContentSearchButton = ComponentConfig<typeof theme, AppConfig, 'contentSearchButton'>;
+export interface ContentSearchButtonProps {
+    /**
+     * The icon displayed in the button.
+     * @defaultValue appConfig.ui.icons.search
+     * @IconifyIcon
+     */
+    icon?: string;
+    /**
+     * The label displayed in the button.
+     * @defaultValue t('contentSearchButton.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 true
+     */
+    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?: ContentSearchButton['slots'] & ButtonProps['ui'];
+    class?: any;
+}
+declare const _default: __VLS_WithSlots<import("vue").DefineComponent<ContentSearchButtonProps, void, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ContentSearchButtonProps> & 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/content/ContentSurround.vue

@@ -0,0 +1,64 @@
+<script>
+import theme from "#build/ui/content/content-surround";
+</script>
+
+<script setup>
+import { computed } from "vue";
+import { Primitive } from "reka-ui";
+import { createReusableTemplate } from "@vueuse/core";
+import { useAppConfig } from "#imports";
+import { tv } from "../../utils/tv";
+import ULink from "../Link.vue";
+import UIcon from "../Icon.vue";
+defineOptions({ inheritAttrs: false });
+const props = defineProps({
+  as: { type: null, required: false },
+  prevIcon: { type: String, required: false },
+  nextIcon: { type: String, required: false },
+  surround: { type: Array, required: false },
+  class: { type: null, required: false },
+  ui: { type: null, required: false }
+});
+defineSlots();
+const appConfig = useAppConfig();
+const [DefineLinkTemplate, ReuseLinkTemplate] = createReusableTemplate({
+  props: {
+    link: Object,
+    icon: String,
+    direction: String
+  }
+});
+const ui = computed(() => tv({ extend: tv(theme), ...appConfig.ui?.contentSurround || {} })());
+</script>
+
+<template>
+  <DefineLinkTemplate v-slot="{ link, icon, direction }">
+    <ULink v-if="link" :to="link.path" raw :class="ui.link({ class: [props.ui?.link, link.ui?.link, link.class], direction })">
+      <slot name="link" :link="link">
+        <div :class="ui.linkLeading({ class: [props.ui?.linkLeading, link.ui?.linkLeading] })">
+          <slot name="link-leading" :link="link">
+            <UIcon :name="link.icon || icon" :class="ui.linkLeadingIcon({ class: [props.ui?.linkLeadingIcon, link.ui?.linkLeadingIcon], direction })" />
+          </slot>
+        </div>
+
+        <p :class="ui.linkTitle({ class: [props.ui?.linkTitle, link.ui?.linkTitle] })">
+          <slot name="link-title" :link="link">
+            {{ link.title }}
+          </slot>
+        </p>
+
+        <p :class="ui.linkDescription({ class: [props.ui?.linkDescription, link.ui?.linkDescription] })">
+          <slot name="link-description" :link="link">
+            {{ link.description }}
+          </slot>
+        </p>
+      </slot>
+    </ULink>
+    <span v-else class="hidden lg:block">&nbsp;</span>
+  </DefineLinkTemplate>
+
+  <Primitive v-if="surround" :as="as" v-bind="$attrs" :class="ui.root({ class: [props.ui?.root, props.class] })">
+    <ReuseLinkTemplate :link="surround[0]" :icon="prevIcon || appConfig.ui.icons.arrowLeft" direction="left" />
+    <ReuseLinkTemplate :link="surround[1]" :icon="nextIcon || appConfig.ui.icons.arrowRight" direction="right" />
+  </Primitive>
+</template>

package/dist/runtime/components/content/ContentSurround.vue.d.ts

@@ -0,0 +1,58 @@
+import type { ContentNavigationItem } from '@nuxt/content';
+import type { AppConfig } from '@nuxt/schema';
+import theme from '#build/ui/content/content-surround';
+import type { ComponentConfig } from '../../types/tv';
+type ContentSurround = ComponentConfig<typeof theme, AppConfig, 'contentSurround'>;
+export interface ContentSurroundLink extends ContentNavigationItem {
+    description?: string;
+    /**
+     * @IconifyIcon
+     */
+    icon?: string;
+    class?: any;
+    ui?: Pick<ContentSurround['slots'], 'link' | 'linkLeading' | 'linkLeadingIcon' | 'linkTitle' | 'linkDescription'>;
+}
+export interface ContentSurroundProps<T extends ContentSurroundLink = ContentSurroundLink> {
+    /**
+     * The element or component this component should render as.
+     * @defaultValue 'div'
+     */
+    as?: any;
+    /**
+     * The icon displayed in the prev link.
+     * @defaultValue appConfig.ui.icons.arrowLeft
+     * @IconifyIcon
+     */
+    prevIcon?: string;
+    /**
+     * The icon displayed in the next link.
+     * @defaultValue appConfig.ui.icons.arrowRight
+     * @IconifyIcon
+     */
+    nextIcon?: string;
+    surround?: T[];
+    class?: any;
+    ui?: ContentSurround['slots'];
+}
+type SlotProps<T> = (props: {
+    link: T;
+}) => any;
+export interface ContentSurroundSlots<T extends ContentSurroundLink = ContentSurroundLink> {
+    'link': SlotProps<T>;
+    'link-leading': SlotProps<T>;
+    'link-title': SlotProps<T>;
+    'link-description': SlotProps<T>;
+}
+declare const _default: <T extends ContentSurroundLink>(__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<{} & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>, never> & ContentSurroundProps<T> & Partial<{}>> & import("vue").PublicProps;
+    expose(exposed: import("vue").ShallowUnwrapRef<{}>): void;
+    attrs: any;
+    slots: ContentSurroundSlots<T>;
+    emit: {};
+}>) => import("vue").VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T as K]: T[K];
+} & {};