una-nuxt-module 2.1.1 → 2.1.3

package/dist/module.mjs

@@ -1,48 +1,51 @@
-import { createResolver, defineNuxtModule, useLogger, extendPages, addLayout, addComponentsDir, addImportsDir, addPlugin, addRouteMiddleware, hasNuxtModule } from '@nuxt/kit';
+import { createResolver, addTemplate, defineNuxtModule, useLogger, extendPages, addLayout, addComponentsDir, addImportsDir, addPlugin, addVitePlugin, addRouteMiddleware, hasNuxtModule } from '@nuxt/kit';
 import { defu } from 'defu';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
 
-const name = "una-nuxt-module";
-const version = "2.1.1";
-
-function resolve(path) {
-  const resolver = createResolver(import.meta.url);
-  return resolver.resolve(`./runtime/${path}`);
-}
-
+const { resolve } = createResolver(import.meta.url);
 const PAGES_CONFIG = [
   {
     name: "401",
     path: "/401",
-    file: resolve("pages/401.vue")
+    file: resolve("./runtime/pages/401.vue")
   },
   {
     name: "403",
     path: "/403",
-    file: resolve("pages/403.vue")
+    file: resolve("./runtime/pages/403.vue")
   },
   {
     name: "ssoCallback",
     path: "/auth/sso/login",
-    file: resolve("pages/ssoCallback.vue")
+    file: resolve("./runtime/pages/ssoCallback.vue")
   }
 ];
 const LAYOUTS_CONFIG = {
-  default: { src: resolve("layouts/default.vue"), name: "default" },
-  empty: { src: resolve("layouts/empty.vue"), name: "empty" }
+  default: { src: resolve("./runtime/layouts/default.vue"), name: "default" },
+  empty: { src: resolve("./runtime/layouts/empty.vue"), name: "empty" }
+};
+const AUTH_PLUGIN = {
+  name: "auth",
+  src: resolve("./runtime/plugins/auth"),
+  mode: "client"
 };
 const PLUGINS_CONFIG = [
-  { name: "auth", src: resolve("plugins/auth"), mode: "client" },
-  { name: "vue-json", src: resolve("plugins/vue-json"), mode: "client" }
+  {
+    name: "vue-json",
+    src: resolve("./runtime/plugins/vue-json"),
+    mode: "client"
+  }
 ];
-const MIDDLEWARE_CONFIG = [
+const AUTH_MIDDLEWARE_CONFIG = [
   {
     name: "authentication",
-    path: resolve("middleware/authentication"),
+    path: resolve("./runtime/middleware/authentication"),
     global: true
   },
   {
     name: "authorization",
-    path: resolve("middleware/authorization"),
+    path: resolve("./runtime/middleware/authorization"),
     global: true
   }
 ];
@@ -52,42 +55,103 @@ const AUTO_IMPORT_DIRS = [
   "enums",
   "stores",
   "types",
-  "utils"
+  "utils",
+  "lib"
 ];
 
+function getShadcnComponentsInstalled() {
+  try {
+    const { resolve } = createResolver(import.meta.url);
+    const directoryPath = resolve("./runtime/components/ui");
+    const filesAndFolders = fs.readdirSync(directoryPath);
+    const folders = filesAndFolders.filter((item) => {
+      const fullPath = path.join(directoryPath, item);
+      return fs.statSync(fullPath).isDirectory();
+    });
+    return folders;
+  } catch (err) {
+    console.error("Error reading directory:", err);
+    return [];
+  }
+}
+function getTemplates() {
+  const { resolve } = createResolver(import.meta.url);
+  const templates = [];
+  const components = getShadcnComponentsInstalled();
+  for (const component of components) {
+    try {
+      const filePath = resolve(`./runtime/components/ui/${component}/index.ts`);
+      const fileContent = fs.readFileSync(filePath, "utf-8");
+      templates.push({
+        filename: `unaxt/${component}.ts`,
+        write: true,
+        getContents: () => fileContent
+      });
+    } catch (error) {
+      console.error(
+        `Error reading file components/ui/${component}/index.ts:`,
+        error
+      );
+    }
+  }
+  templates.push({
+    filename: "unaxt.css",
+    write: true,
+    getContents: () => `@source "./unaxt";
+
+@theme default {}
+`
+  });
+  return templates;
+}
+function addTemplates() {
+  const templates = getTemplates();
+  for (const template of templates) {
+    addTemplate(template);
+  }
+}
+
+const name = "una-nuxt-module";
+const version = "2.1.3";
+
 const module = defineNuxtModule({
   meta: {
-    name: name,
-    version: version,
-    configKey: "unaNuxtModule"
+    name,
+    version,
+    configKey: "unaxt"
   },
   defaults: {
     use: {
       layout: {
         default: false,
         empty: false
-      }
+      },
+      sso: true,
+      components: true
     }
   },
-  async setup(_options, _nuxt) {
+  async setup(options, nuxt) {
     const logger = useLogger(name);
-    const validateIDToken = import.meta.dev ? _nuxt.options.runtimeConfig.public.unaNuxtModule.sso.validateIDToken ?? false : true;
+    const { resolve } = createResolver(import.meta.url);
+    nuxt.options.unaxt = options;
+    nuxt.options.alias["#unaxt"] = resolve("./runtime");
     const mergeRuntimeConfigWithDefaults = () => {
-      _nuxt.options.runtimeConfig.public.unaNuxtModule = defu(
-        _nuxt.options.runtimeConfig.public.unaNuxtModule,
+      const validateIDToken = import.meta.dev ? nuxt.options.runtimeConfig.public.unaNuxtModule.sso.validateIDToken ?? false : true;
+      nuxt.options.runtimeConfig.public.unaNuxtModule = defu(
+        nuxt.options.runtimeConfig.public.unaNuxtModule,
         {
           sso: { validateIDToken },
           use: {
             layout: {
-              default: _options.use.layout.default,
-              empty: _options.use.layout.empty
+              default: options.use.layout.default,
+              empty: options.use.layout.empty
             }
           }
         }
       );
     };
     const setupPublicAssets = () => {
-      _nuxt.options.nitro.publicAssets = [{ dir: resolve("public") }];
+      nuxt.options.nitro.publicAssets = [{ dir: resolve("./runtime/public") }];
       logger.success("Public assets added");
     };
     const setupPages = () => {
@@ -97,24 +161,33 @@ const module = defineNuxtModule({
       logger.success("Custom pages added: ['/401', '/403', '/auth/sso/login']");
     };
     const setupLayouts = () => {
-      const addLayoutDefault = _nuxt.options.runtimeConfig.public.unaNuxtModule.use.layout.default;
+      const addLayoutDefault = nuxt.options.runtimeConfig.public.unaNuxtModule.use.layout.default;
       if (addLayoutDefault) {
         addLayout(LAYOUTS_CONFIG.default, LAYOUTS_CONFIG.default.name);
         logger.success("Layout added: default");
       }
-      const addLayoutEmpty = _nuxt.options.runtimeConfig.public.unaNuxtModule.use.layout.empty;
+      const addLayoutEmpty = nuxt.options.runtimeConfig.public.unaNuxtModule.use.layout.empty;
       if (addLayoutEmpty) {
         addLayout(LAYOUTS_CONFIG.empty, LAYOUTS_CONFIG.empty.name);
         logger.success("Layout added: empty");
       }
     };
     const setupComponents = () => {
-      addComponentsDir({
-        path: resolve("components"),
-        pathPrefix: false,
-        global: true
-      });
-      logger.success("Global components added");
+      if (nuxt.options.runtimeConfig.public.unaNuxtModule.use.components) {
+        addComponentsDir(
+          {
+            path: resolve("./runtime/components/ui"),
+            extensions: [".vue"],
+            prefix: "",
+            pathPrefix: false,
+            global: true
+          },
+          {
+            prepend: true
+          }
+        );
+        logger.success("Global components added");
+      }
     };
     const setupAutoImports = () => {
       addImportsDir(AUTO_IMPORT_DIRS.map((dir) => resolve(dir)));
@@ -122,21 +195,42 @@ const module = defineNuxtModule({
         `Auto-import directories added: [${AUTO_IMPORT_DIRS.join(", ")}]`
       );
     };
+    const setupSSO = () => {
+      if (nuxt.options.runtimeConfig.public.unaNuxtModule.use.sso) {
+        addPlugin(AUTH_PLUGIN);
+        logger.success("Auth plugin added... SSO configurado");
+      }
+    };
     const setupPlugins = () => {
       PLUGINS_CONFIG.forEach((plugin) => addPlugin(plugin));
-      logger.success("Plugins added: ['auth', 'vue-json']");
+      logger.success("Plugins added: ['vue-json']");
     };
-    const setupMiddleware = () => {
-      MIDDLEWARE_CONFIG.forEach((middleware) => addRouteMiddleware(middleware));
-      logger.success("Middleware added: ['authentication', 'authorization']");
+    const setupTailwindPlugin = async () => {
+      if (nuxt.options.builder === "@nuxt/vite-builder") {
+        const plugin = await import('@tailwindcss/vite').then((r) => r.default);
+        addVitePlugin(plugin());
+      } else {
+        nuxt.options.postcss.plugins["@tailwindcss/postcss"] = {};
+      }
+    };
+    const setupAuthMiddlewares = () => {
+      if (nuxt.options.runtimeConfig.public.unaNuxtModule.use.sso) {
+        AUTH_MIDDLEWARE_CONFIG.forEach(
+          (middleware) => addRouteMiddleware(middleware)
+        );
+        logger.success("Middleware added: ['authentication', 'authorization']");
+      }
     };
     const setupI18n = () => {
-      if (!hasNuxtModule("@nuxtjs/i18n", _nuxt)) {
-        throw new Error("@nuxtjs/i18n module is required but not installed");
+      if (!hasNuxtModule("@nuxtjs/i18n", nuxt)) {
+        console.log(
+          "@nuxtjs/i18n module is not installed, i18n extend messages skipped"
+        );
+        return;
       }
-      _nuxt.hook("i18n:registerModule", (register) => {
+      nuxt.hook("i18n:registerModule", (register) => {
         register({
-          langDir: resolve("i18n/locales"),
+          langDir: resolve("./runtime/i18n/locales"),
           locales: [{ code: "es", file: "es.json" }]
         });
       });
@@ -151,9 +245,12 @@ const module = defineNuxtModule({
       setupLayouts();
       setupComponents();
       setupAutoImports();
+      setupSSO();
       setupPlugins();
-      setupMiddleware();
+      await setupTailwindPlugin();
+      setupAuthMiddlewares();
       setupI18n();
+      addTemplates();
       logger.success("Module setup completed successfully\n");
     } catch (error) {
       logger.error("Module setup failed");

package/dist/runtime/components/ui/accordion/Accordion.vue

@@ -0,0 +1,26 @@
+<script setup>
+import {
+  AccordionRoot,
+  useForwardPropsEmits
+} from "reka-ui";
+const props = defineProps({
+  collapsible: { type: Boolean, required: false },
+  disabled: { type: Boolean, required: false },
+  dir: { type: String, required: false },
+  orientation: { type: String, required: false },
+  unmountOnHide: { type: Boolean, required: false },
+  asChild: { type: Boolean, required: false },
+  as: { type: [String, Object, Function], required: false },
+  type: { type: String, required: false },
+  modelValue: { type: null, required: false },
+  defaultValue: { type: null, required: false }
+});
+const emits = defineEmits(["update:modelValue"]);
+const forwarded = useForwardPropsEmits(props, emits);
+</script>
+
+<template>
+  <AccordionRoot data-slot="accordion" v-bind="forwarded">
+    <slot />
+  </AccordionRoot>
+</template>

package/dist/runtime/components/ui/accordion/Accordion.vue.d.ts

@@ -0,0 +1,26 @@
+import { type AccordionRootProps } from 'reka-ui';
+declare function __VLS_template(): {
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    attrs: Partial<{}>;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import("vue").DefineComponent<import("vue").ExtractPropTypes<__VLS_TypePropsToOption<AccordionRootProps<string | string[]>>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, any, string, import("vue").PublicProps, any, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/ui/accordion/AccordionContent.vue

@@ -0,0 +1,24 @@
+<script setup>
+import { reactiveOmit } from "@vueuse/core";
+import { AccordionContent } from "reka-ui";
+import { cn } from "../../../lib/utils";
+const props = defineProps({
+  forceMount: { type: Boolean, required: false },
+  asChild: { type: Boolean, required: false },
+  as: { type: [String, Object, Function], required: false },
+  class: { type: null, required: false }
+});
+const delegatedProps = reactiveOmit(props, "class");
+</script>
+
+<template>
+  <AccordionContent
+    data-slot="accordion-content"
+    v-bind="delegatedProps"
+    class="data-[state=closed]:animate-accordion-up data-[state=open]:animate-accordion-down overflow-hidden text-sm"
+  >
+    <div :class="cn('pt-0 pb-4', props.class)">
+      <slot />
+    </div>
+  </AccordionContent>
+</template>

package/dist/runtime/components/ui/accordion/AccordionContent.vue.d.ts

@@ -0,0 +1,31 @@
+import type { HTMLAttributes } from "vue";
+import { type AccordionContentProps } from "reka-ui";
+declare function __VLS_template(): {
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    attrs: Partial<{}>;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import("vue").DefineComponent<import("vue").ExtractPropTypes<__VLS_TypePropsToOption<AccordionContentProps & {
+    class?: HTMLAttributes["class"];
+}>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_TypePropsToOption<AccordionContentProps & {
+    class?: HTMLAttributes["class"];
+}>>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/ui/accordion/AccordionItem.vue

@@ -0,0 +1,28 @@
+<script setup>
+import { reactiveOmit } from "@vueuse/core";
+import {
+  AccordionItem,
+  useForwardProps
+} from "reka-ui";
+import { cn } from "../../../lib/utils";
+const props = defineProps({
+  disabled: { type: Boolean, required: false },
+  value: { type: String, required: true },
+  unmountOnHide: { type: Boolean, required: false },
+  asChild: { type: Boolean, required: false },
+  as: { type: [String, Object, Function], required: false },
+  class: { type: null, required: false }
+});
+const delegatedProps = reactiveOmit(props, "class");
+const forwardedProps = useForwardProps(delegatedProps);
+</script>
+
+<template>
+  <AccordionItem
+    data-slot="accordion-item"
+    v-bind="forwardedProps"
+    :class="cn('border-b last:border-b-0', props.class)"
+  >
+    <slot />
+  </AccordionItem>
+</template>

package/dist/runtime/components/ui/accordion/AccordionItem.vue.d.ts

@@ -0,0 +1,31 @@
+import type { HTMLAttributes } from "vue";
+import { type AccordionItemProps } from "reka-ui";
+declare function __VLS_template(): {
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    attrs: Partial<{}>;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import("vue").DefineComponent<import("vue").ExtractPropTypes<__VLS_TypePropsToOption<AccordionItemProps & {
+    class?: HTMLAttributes["class"];
+}>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_TypePropsToOption<AccordionItemProps & {
+    class?: HTMLAttributes["class"];
+}>>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/ui/accordion/AccordionTrigger.vue

@@ -0,0 +1,37 @@
+<script setup>
+import { reactiveOmit } from "@vueuse/core";
+import { ChevronDown } from "lucide-vue-next";
+import {
+  AccordionHeader,
+  AccordionTrigger
+} from "reka-ui";
+import { cn } from "../../../lib/utils";
+const props = defineProps({
+  asChild: { type: Boolean, required: false },
+  as: { type: [String, Object, Function], required: false },
+  class: { type: null, required: false }
+});
+const delegatedProps = reactiveOmit(props, "class");
+</script>
+
+<template>
+  <AccordionHeader class="flex">
+    <AccordionTrigger
+      data-slot="accordion-trigger"
+      v-bind="delegatedProps"
+      :class="
+  cn(
+    'focus-visible:border-ring focus-visible:ring-ring/50 flex flex-1 items-start justify-between gap-4 rounded-md py-4 text-left text-sm font-medium transition-all outline-none hover:underline focus-visible:ring-[3px] disabled:pointer-events-none disabled:opacity-50 [&[data-state=open]>svg]:rotate-180',
+    props.class
+  )
+"
+    >
+      <slot />
+      <slot name="icon">
+        <ChevronDown
+          class="text-muted-foreground pointer-events-none size-4 shrink-0 translate-y-0.5 transition-transform duration-200"
+        />
+      </slot>
+    </AccordionTrigger>
+  </AccordionHeader>
+</template>

package/dist/runtime/components/ui/accordion/AccordionTrigger.vue.d.ts

@@ -0,0 +1,32 @@
+import type { HTMLAttributes } from "vue";
+import { type AccordionTriggerProps } from "reka-ui";
+declare function __VLS_template(): {
+    slots: {
+        default?(_: {}): any;
+        icon?(_: {}): any;
+    };
+    refs: {};
+    attrs: Partial<{}>;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import("vue").DefineComponent<import("vue").ExtractPropTypes<__VLS_TypePropsToOption<AccordionTriggerProps & {
+    class?: HTMLAttributes["class"];
+}>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_TypePropsToOption<AccordionTriggerProps & {
+    class?: HTMLAttributes["class"];
+}>>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/ui/accordion/index.d.ts

@@ -0,0 +1,4 @@
+export { default as Accordion } from './Accordion.vue.js';
+export { default as AccordionContent } from './AccordionContent.vue.js';
+export { default as AccordionItem } from './AccordionItem.vue.js';
+export { default as AccordionTrigger } from './AccordionTrigger.vue.js';

package/dist/runtime/components/ui/accordion/index.js

@@ -0,0 +1,4 @@
+export { default as Accordion } from "./Accordion.vue";
+export { default as AccordionContent } from "./AccordionContent.vue";
+export { default as AccordionItem } from "./AccordionItem.vue";
+export { default as AccordionTrigger } from "./AccordionTrigger.vue";

package/dist/runtime/components/ui/alert/Alert.vue

@@ -0,0 +1,18 @@
+<script setup>
+import { cn } from "../../../lib/utils";
+import { alertVariants } from ".";
+const props = defineProps({
+  class: { type: null, required: false },
+  variant: { type: null, required: false }
+});
+</script>
+
+<template>
+  <div
+    data-slot="alert"
+    :class="cn(alertVariants({ variant }), props.class)"
+    role="alert"
+  >
+    <slot />
+  </div>
+</template>

package/dist/runtime/components/ui/alert/Alert.vue.d.ts

@@ -0,0 +1,33 @@
+import type { HTMLAttributes } from "vue";
+import { type AlertVariants } from ".";
+declare function __VLS_template(): {
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    attrs: Partial<{}>;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import("vue").DefineComponent<import("vue").ExtractPropTypes<__VLS_TypePropsToOption<{
+    class?: HTMLAttributes["class"];
+    variant?: AlertVariants["variant"];
+}>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_TypePropsToOption<{
+    class?: HTMLAttributes["class"];
+    variant?: AlertVariants["variant"];
+}>>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/ui/alert/AlertDescription.vue

@@ -0,0 +1,20 @@
+<script setup>
+import { cn } from "../../../lib/utils";
+const props = defineProps({
+  class: { type: null, required: false }
+});
+</script>
+
+<template>
+  <div
+    data-slot="alert-description"
+    :class="
+  cn(
+    'text-muted-foreground col-start-2 grid justify-items-start gap-1 text-sm [&_p]:leading-relaxed',
+    props.class
+  )
+"
+  >
+    <slot />
+  </div>
+</template>

package/dist/runtime/components/ui/alert/AlertDescription.vue.d.ts

@@ -0,0 +1,30 @@
+import type { HTMLAttributes } from "vue";
+declare function __VLS_template(): {
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    attrs: Partial<{}>;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import("vue").DefineComponent<import("vue").ExtractPropTypes<__VLS_TypePropsToOption<{
+    class?: HTMLAttributes["class"];
+}>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_TypePropsToOption<{
+    class?: HTMLAttributes["class"];
+}>>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};