import { defu } from 'defu';
import { defineNuxtModule, createResolver, addPlugin, hasNuxtModule, addPluginTemplate, addComponentsDir, addImportsDir, addImports } from '@nuxt/kit';
import { d as defaultOptions, r as resolveColors, c as getDefaultConfig, g as getClientBundleIcons, f as publicComposables, a as addTemplates } from './shared/ui.Ba0YYeuK.mjs';
import { readdirSync } from 'node:fs';
import { genImport, genObjectFromRawEntries } from 'knitwork';
import { join } from 'pathe';
import '../dist/runtime/utils/index.js';
import 'node:url';
import 'scule';
import 'tailwindcss/colors';
import 'node:fs/promises';
import 'consola';
import 'tinyglobby';
import 'mlly';

function getLocaleKeys(localeDir) {
  return readdirSync(localeDir).map((file) => file.match(/^([a-z_]+)\.[jt]s$/)?.[1]).filter((key) => !!key && key !== "index");
}
function resolveLocaleKey(locale, keys) {
  const tags = (typeof locale === "string" ? [locale] : [locale.language, locale.code]).filter((tag) => !!tag);
  const candidates = [...tags, ...tags.map((tag) => tag.split(/[-_]/)[0])].map((tag) => tag.toLowerCase().replace(/-/g, "_"));
  const key = candidates.find((key2) => keys.includes(key2));
  if (key) {
    return key;
  }
  for (const candidate of candidates) {
    const regional = keys.filter((key2) => key2.startsWith(`${candidate}_`));
    if (regional.length === 1) {
      return regional[0];
    }
  }
}
function generateI18nPlugin(locales, keys, runtimeDir) {
  const imports = /* @__PURE__ */ new Set();
  const entries = [];
  for (const locale of locales) {
    const key = resolveLocaleKey(locale, keys);
    if (!key) {
      continue;
    }
    imports.add(key);
    entries.push([typeof locale === "string" ? locale : locale.code, key]);
  }
  return [
    genImport("vue", ["computed", "unref"]),
    genImport("#app/nuxt", ["defineNuxtPlugin"]),
    genImport(join(runtimeDir, "composables/useLocale"), ["localeContextInjectionKey"]),
    ...[...imports].map((key) => genImport(join(runtimeDir, "locale", key), key)),
    `const locales = ${genObjectFromRawEntries(entries)}`,
    `export default defineNuxtPlugin((nuxtApp) => {`,
    `  nuxtApp.vueApp.provide(localeContextInjectionKey, computed(() => locales[unref(nuxtApp.$i18n?.locale)]))`,
    `})`
  ].join("\n");
}

const name = "@nuxt/ui";
const version = "4.12.0";

const module$1 = defineNuxtModule({
  meta: {
    name,
    version,
    docs: "https://ui.nuxt.com/docs/getting-started/installation/nuxt",
    configKey: "ui",
    compatibility: {
      nuxt: ">=4.1.0"
    }
  },
  defaults: defaultOptions,
  moduleDependencies(nuxt) {
    const userUiOptions = nuxt.options.ui || {};
    return {
      "@nuxt/icon": {
        defaults: {
          cssLayer: "base"
        }
      },
      ...userUiOptions.fonts !== false && {
        "@nuxt/fonts": {
          defaults: {
            defaults: {
              weights: [400, 500, 600, 700]
            }
          }
        }
      },
      ...userUiOptions.colorMode !== false && {
        "@nuxtjs/color-mode": {
          defaults: {
            classSuffix: "",
            disableTransition: true
          }
        }
      },
      "@nuxtjs/mdc": {
        optional: !userUiOptions.mdc,
        defaults: {
          highlight: {
            theme: {
              light: "material-theme-lighter",
              default: "material-theme",
              dark: "material-theme-palenight"
            }
          },
          components: {
            map: {
              "accordion": "ProseAccordion",
              "accordion-item": "ProseAccordionItem",
              "badge": "ProseBadge",
              "callout": "ProseCallout",
              "card": "ProseCard",
              "card-group": "ProseCardGroup",
              "caution": "ProseCaution",
              "code-collapse": "ProseCodeCollapse",
              "code-group": "ProseCodeGroup",
              "code-icon": "ProseCodeIcon",
              "code-preview": "ProseCodePreview",
              "code-tree": "ProseCodeTree",
              "collapsible": "ProseCollapsible",
              "field": "ProseField",
              "field-group": "ProseFieldGroup",
              "icon": "ProseIcon",
              "kbd": "ProseKbd",
              "note": "ProseNote",
              "prompt": "ProsePrompt",
              "steps": "ProseSteps",
              "tabs": "ProseTabs",
              "tabs-item": "ProseTabsItem",
              "tip": "ProseTip",
              "warning": "ProseWarning"
            }
          }
        }
      }
    };
  },
  async setup(options, nuxt) {
    const { resolve } = createResolver(import.meta.url);
    options.theme = options.theme || {};
    options.theme.colors = resolveColors(options.theme.colors);
    nuxt.options.ui = options;
    nuxt.options.alias["#ui"] = resolve("./runtime");
    nuxt.options.appConfig.ui = defu(nuxt.options.appConfig.ui || {}, getDefaultConfig(options.theme));
    nuxt.hook("icon:clientBundleIcons", (icons) => {
      for (const name2 of getClientBundleIcons(nuxt.options.appConfig.ui?.icons)) {
        icons.add(name2);
      }
    });
    nuxt.options.build.transpile.push("reka-ui");
    nuxt.options.app.rootAttrs = nuxt.options.app.rootAttrs || {};
    nuxt.options.app.rootAttrs.class = [nuxt.options.app.rootAttrs.class, `${options.theme?.prefix ? options.theme.prefix + ":" : ""}isolate`].filter(Boolean).join(" ");
    nuxt.hook("vite:extend", async ({ config }) => {
      const plugin = await import('@tailwindcss/vite').then((r) => r.default);
      config.plugins ||= [];
      config.plugins.push(plugin());
    });
    if (nuxt.options.builder !== "@nuxt/vite-builder") {
      nuxt.options.postcss.plugins["@tailwindcss/postcss"] = {};
    }
    addPlugin({ src: resolve("./runtime/plugins/colors") });
    if (hasNuxtModule("@nuxtjs/i18n")) {
      addPluginTemplate({
        filename: "ui-i18n.mjs",
        getContents: () => {
          const { locales } = nuxt.options.runtimeConfig.public.i18n || {};
          return generateI18nPlugin(Array.isArray(locales) ? locales : [], getLocaleKeys(resolve("./runtime/locale")), resolve("./runtime"));
        }
      });
    }
    if (options.prose || options.mdc || options.content || hasNuxtModule("@nuxtjs/mdc") || hasNuxtModule("@nuxt/content")) {
      addComponentsDir({
        path: resolve("./runtime/components/prose"),
        pathPrefix: false,
        prefix: "Prose",
        // Skip the `index` barrel
        extensions: ["vue"],
        global: true
      });
    }
    if (options.content || hasNuxtModule("@nuxt/content")) {
      addComponentsDir({
        path: resolve("./runtime/components/content"),
        pathPrefix: false,
        prefix: options.prefix
      });
    }
    if (options.colorMode || hasNuxtModule("@nuxtjs/color-mode")) {
      addComponentsDir({
        path: resolve("./runtime/components/color-mode"),
        pathPrefix: false,
        prefix: options.prefix
      });
    } else {
      addImportsDir(resolve("./runtime/composables/color-mode"));
    }
    addComponentsDir({
      path: resolve("./runtime/components"),
      pathPrefix: false,
      prefix: options.prefix,
      ignore: ["color-mode/**", "content/**", "prose/**"]
    });
    addImports(
      Object.entries(publicComposables).flatMap(
        ([file, exports]) => exports.map((name2) => ({ name: name2, from: resolve(`./runtime/composables/${file}`) }))
      )
    );
    addTemplates(options, nuxt, resolve);
  }
});

export { module$1 as default };