@nuxt/ui 3.0.0-alpha.7 → 3.0.0-alpha.9

package/dist/unplugin.cjs

@@ -0,0 +1,192 @@
+'use strict';
+
+const node_url = require('node:url');
+const pathe = require('pathe');
+const unplugin = require('unplugin');
+const AutoImport = require('unplugin-auto-import');
+const defu = require('defu');
+const tailwind = require('@tailwindcss/vite');
+const templates = require('./shared/ui.BPnAe4QS.cjs');
+const tinyglobby = require('tinyglobby');
+const knitwork = require('knitwork');
+const MagicString = require('magic-string');
+const mlly = require('mlly');
+const AutoImportComponents = require('unplugin-vue-components');
+require('../dist/runtime/utils/index.js');
+require('scule');
+require('@nuxt/kit');
+
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
+
+const AutoImport__default = /*#__PURE__*/_interopDefaultCompat(AutoImport);
+const tailwind__default = /*#__PURE__*/_interopDefaultCompat(tailwind);
+const MagicString__default = /*#__PURE__*/_interopDefaultCompat(MagicString);
+const AutoImportComponents__default = /*#__PURE__*/_interopDefaultCompat(AutoImportComponents);
+
+function TemplatePlugin(options, appConfig) {
+  const templates$1 = templates.getTemplates(options, appConfig.ui);
+  const templateKeys = new Set(templates$1.map((t) => `#build/${t.filename}`));
+  return {
+    name: "nuxt:ui:templates",
+    enforce: "pre",
+    resolveId(id) {
+      if (templateKeys.has(id + ".ts")) {
+        return id.replace("#build/", "virtual:nuxt-ui-templates/") + ".ts";
+      }
+    },
+    loadInclude: (id) => templateKeys.has(id.replace("virtual:nuxt-ui-templates/", "#build/")),
+    load(id) {
+      id = id.replace("virtual:nuxt-ui-templates/", "#build/");
+      return templates$1.find((t) => `#build/${t.filename}` === id).getContents({});
+    }
+  };
+}
+
+function PluginsPlugin(options) {
+  const plugins = tinyglobby.globSync(["**/*", "!*.d.ts"], { cwd: pathe.join(runtimeDir, "plugins"), absolute: true });
+  plugins.unshift(mlly.resolvePathSync(pathe.join(runtimeDir, "vue/plugins/head"), { extensions: [".ts", ".mjs", ".js"] }));
+  if (options.colorMode) {
+    plugins.push(mlly.resolvePathSync(pathe.join(runtimeDir, "vue/plugins/color-mode"), { extensions: [".ts", ".mjs", ".js"] }));
+  }
+  return {
+    name: "nuxt:ui:plugins",
+    enforce: "pre",
+    resolveId(id) {
+      if (id === "@nuxt/ui/vue-plugin") {
+        return "virtual:nuxt-ui-plugins";
+      }
+    },
+    transform(code, id) {
+      if (plugins.some((p) => id.startsWith(p)) && code.includes("import.meta.client")) {
+        const s = new MagicString__default(code);
+        s.replaceAll("import.meta.client", "true");
+        if (s.hasChanged()) {
+          return {
+            code: s.toString(),
+            map: s.generateMap({ hires: true })
+          };
+        }
+      }
+    },
+    loadInclude: (id) => id === "virtual:nuxt-ui-plugins",
+    load() {
+      return `
+        ${plugins.map((p) => `import ${knitwork.genSafeVariableName(p)} from "${p}"`).join("\n")}
+export default {
+  install (app) {
+${plugins.map((p) => `    app.use(${knitwork.genSafeVariableName(p)})`).join("\n")}
+  }
+}
+        `;
+    }
+  };
+}
+
+function AppConfigPlugin(options, appConfig) {
+  return {
+    name: "nuxt:ui:app-config",
+    enforce: "pre",
+    resolveId(id) {
+      if (id === "#build/app.config") {
+        return "virtual:nuxt-ui-app-config";
+      }
+    },
+    loadInclude: (id) => id === "virtual:nuxt-ui-app-config",
+    load() {
+      return `
+          export default ${JSON.stringify(appConfig)}
+        `;
+    }
+  };
+}
+
+function ComponentImportPlugin(framework, options) {
+  const components = tinyglobby.globSync("**/*.vue", { cwd: pathe.join(runtimeDir, "components") });
+  const componentNames = new Set(components.map((c) => `${options.prefix}${c.replace(/\.vue$/, "")}`));
+  const overrides = tinyglobby.globSync("**/*.vue", { cwd: pathe.join(runtimeDir, "vue/components") });
+  const overrideNames = new Set(overrides.map((c) => `${options.prefix}${c.replace(/\.vue$/, "")}`));
+  return [
+    /**
+     * This plugin aims to ensure we override certain components with Vue-compatible versions:
+     * <UIcon> and <ULink> currently.
+     */
+    {
+      name: "nuxt:ui:components",
+      enforce: "pre",
+      resolveId(id, importer) {
+        if (!importer || !pathe.normalize(importer).includes(runtimeDir)) {
+          return;
+        }
+        if (!RELATIVE_IMPORT_RE.test(id)) {
+          return;
+        }
+        const filename = id.match(/([^/]+)\.vue$/)?.[1];
+        if (filename && overrideNames.has(`${options.prefix}${filename}`)) {
+          return pathe.join(runtimeDir, "vue/components", `${filename}.vue`);
+        }
+      }
+    },
+    AutoImportComponents__default[framework]({
+      dts: options.dts ?? true,
+      exclude: [/[\\/]node_modules[\\/](?!\.pnpm|@nuxt\/ui)/, /[\\/]\.git[\\/]/, /[\\/]\.nuxt[\\/]/],
+      resolvers: [
+        (componentName) => {
+          if (overrideNames.has(componentName))
+            return { name: "default", from: pathe.join(runtimeDir, "vue/components", `${componentName.slice(options.prefix.length)}.vue`) };
+          if (componentNames.has(componentName))
+            return { name: "default", from: pathe.join(runtimeDir, "components", `${componentName.slice(options.prefix.length)}.vue`) };
+        }
+      ]
+    })
+  ];
+}
+const RELATIVE_IMPORT_RE = /^\.{1,2}\//;
+
+function NuxtEnvironmentPlugin() {
+  const stubPath = mlly.resolvePathSync(pathe.join(runtimeDir, "vue/stubs"), { extensions: [".ts", ".mjs", ".js"] });
+  return {
+    name: "nuxt:ui",
+    enforce: "pre",
+    resolveId(id) {
+      if (id === "#imports") {
+        return stubPath;
+      }
+    },
+    transformInclude(id) {
+      return pathe.normalize(id).includes(runtimeDir);
+    },
+    transform(code) {
+      if (code.includes("import.meta.client")) {
+        const s = new MagicString__default(code);
+        s.replaceAll("import.meta.client", "true");
+        if (s.hasChanged()) {
+          return {
+            code: s.toString(),
+            map: s.generateMap({ hires: true })
+          };
+        }
+      }
+    }
+  };
+}
+
+const runtimeDir = node_url.fileURLToPath(new URL("./runtime", (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('unplugin.cjs', document.baseURI).href))));
+const NuxtUIPlugin = unplugin.createUnplugin((_options = {}, meta) => {
+  const options = defu.defu(_options, { fonts: false, devtools: { enabled: false } }, templates.defaultOptions);
+  options.theme = options.theme || {};
+  options.theme.colors = templates.resolveColors(options.theme.colors);
+  const appConfig = defu.defu({ ui: options.ui }, { ui: templates.getDefaultUiConfig(options.theme.colors) });
+  return [
+    NuxtEnvironmentPlugin(),
+    ...ComponentImportPlugin(meta.framework, options),
+    AutoImport__default[meta.framework]({ dts: options.dts ?? true, dirs: [pathe.join(runtimeDir, "composables")] }),
+    tailwind__default(),
+    PluginsPlugin(options),
+    TemplatePlugin(options, appConfig),
+    AppConfigPlugin(options, appConfig)
+  ];
+});
+
+exports.NuxtUIPlugin = NuxtUIPlugin;
+exports.runtimeDir = runtimeDir;

package/dist/unplugin.d.cts

@@ -0,0 +1,49 @@
+import * as unplugin from 'unplugin';
+import colors from 'tailwindcss/colors';
+import * as ui from '#build/ui';
+import { ModuleOptions } from './module.cjs';
+import { DeepPartial } from '../dist/runtime/types/utils.js';
+import '@nuxt/schema';
+import '../dist/runtime/types/index.js';
+
+declare const _default: {
+    arrowLeft: string;
+    arrowRight: string;
+    check: string;
+    chevronDoubleLeft: string;
+    chevronDoubleRight: string;
+    chevronDown: string;
+    chevronLeft: string;
+    chevronRight: string;
+    close: string;
+    ellipsis: string;
+    external: string;
+    loading: string;
+    minus: string;
+    plus: string;
+    search: string;
+    chevronUp: string;
+};
+
+type NeutralColor = 'slate' | 'gray' | 'zinc' | 'neutral' | 'stone';
+type Color = Exclude<keyof typeof colors, 'inherit' | 'current' | 'transparent' | 'black' | 'white' | NeutralColor> | (string & {});
+type AppConfigUI = {
+    colors?: Record<string, Color> & {
+        neutral?: NeutralColor;
+    };
+    icons?: Partial<typeof _default>;
+} & DeepPartial<typeof ui>;
+interface NuxtUIOptions extends Omit<ModuleOptions, 'fonts' | 'colorMode'> {
+    /** Whether to generate declaration files for auto-imported components. */
+    dts?: boolean;
+    ui?: AppConfigUI;
+    /**
+     * Enable or disable `@vueuse/core` color-mode integration
+     * @defaultValue `true`
+     */
+    colorMode?: boolean;
+}
+declare const runtimeDir: string;
+declare const NuxtUIPlugin: unplugin.UnpluginInstance<NuxtUIOptions | undefined, boolean>;
+
+export { type NuxtUIOptions, NuxtUIPlugin, runtimeDir };

package/dist/unplugin.d.mts

@@ -0,0 +1,49 @@
+import * as unplugin from 'unplugin';
+import colors from 'tailwindcss/colors';
+import * as ui from '#build/ui';
+import { ModuleOptions } from './module.mjs';
+import { DeepPartial } from '../dist/runtime/types/utils.js';
+import '@nuxt/schema';
+import '../dist/runtime/types/index.js';
+
+declare const _default: {
+    arrowLeft: string;
+    arrowRight: string;
+    check: string;
+    chevronDoubleLeft: string;
+    chevronDoubleRight: string;
+    chevronDown: string;
+    chevronLeft: string;
+    chevronRight: string;
+    close: string;
+    ellipsis: string;
+    external: string;
+    loading: string;
+    minus: string;
+    plus: string;
+    search: string;
+    chevronUp: string;
+};
+
+type NeutralColor = 'slate' | 'gray' | 'zinc' | 'neutral' | 'stone';
+type Color = Exclude<keyof typeof colors, 'inherit' | 'current' | 'transparent' | 'black' | 'white' | NeutralColor> | (string & {});
+type AppConfigUI = {
+    colors?: Record<string, Color> & {
+        neutral?: NeutralColor;
+    };
+    icons?: Partial<typeof _default>;
+} & DeepPartial<typeof ui>;
+interface NuxtUIOptions extends Omit<ModuleOptions, 'fonts' | 'colorMode'> {
+    /** Whether to generate declaration files for auto-imported components. */
+    dts?: boolean;
+    ui?: AppConfigUI;
+    /**
+     * Enable or disable `@vueuse/core` color-mode integration
+     * @defaultValue `true`
+     */
+    colorMode?: boolean;
+}
+declare const runtimeDir: string;
+declare const NuxtUIPlugin: unplugin.UnpluginInstance<NuxtUIOptions | undefined, boolean>;
+
+export { type NuxtUIOptions, NuxtUIPlugin, runtimeDir };

package/dist/unplugin.d.ts

@@ -0,0 +1,49 @@
+import * as unplugin from 'unplugin';
+import colors from 'tailwindcss/colors';
+import * as ui from '#build/ui';
+import { ModuleOptions } from './module.js';
+import { DeepPartial } from '../dist/runtime/types/utils.js';
+import '@nuxt/schema';
+import '../dist/runtime/types/index.js';
+
+declare const _default: {
+    arrowLeft: string;
+    arrowRight: string;
+    check: string;
+    chevronDoubleLeft: string;
+    chevronDoubleRight: string;
+    chevronDown: string;
+    chevronLeft: string;
+    chevronRight: string;
+    close: string;
+    ellipsis: string;
+    external: string;
+    loading: string;
+    minus: string;
+    plus: string;
+    search: string;
+    chevronUp: string;
+};
+
+type NeutralColor = 'slate' | 'gray' | 'zinc' | 'neutral' | 'stone';
+type Color = Exclude<keyof typeof colors, 'inherit' | 'current' | 'transparent' | 'black' | 'white' | NeutralColor> | (string & {});
+type AppConfigUI = {
+    colors?: Record<string, Color> & {
+        neutral?: NeutralColor;
+    };
+    icons?: Partial<typeof _default>;
+} & DeepPartial<typeof ui>;
+interface NuxtUIOptions extends Omit<ModuleOptions, 'fonts' | 'colorMode'> {
+    /** Whether to generate declaration files for auto-imported components. */
+    dts?: boolean;
+    ui?: AppConfigUI;
+    /**
+     * Enable or disable `@vueuse/core` color-mode integration
+     * @defaultValue `true`
+     */
+    colorMode?: boolean;
+}
+declare const runtimeDir: string;
+declare const NuxtUIPlugin: unplugin.UnpluginInstance<NuxtUIOptions | undefined, boolean>;
+
+export { type NuxtUIOptions, NuxtUIPlugin, runtimeDir };

package/dist/unplugin.mjs

@@ -0,0 +1,181 @@
+import { fileURLToPath } from 'node:url';
+import { join, normalize } from 'pathe';
+import { createUnplugin } from 'unplugin';
+import AutoImport from 'unplugin-auto-import';
+import { defu } from 'defu';
+import tailwind from '@tailwindcss/vite';
+import { g as getTemplates, d as defaultOptions, r as resolveColors, a as getDefaultUiConfig } from './shared/ui.d52SSCwA.mjs';
+import { globSync } from 'tinyglobby';
+import { genSafeVariableName } from 'knitwork';
+import MagicString from 'magic-string';
+import { resolvePathSync } from 'mlly';
+import AutoImportComponents from 'unplugin-vue-components';
+import '../dist/runtime/utils/index.js';
+import 'scule';
+import '@nuxt/kit';
+
+function TemplatePlugin(options, appConfig) {
+  const templates = getTemplates(options, appConfig.ui);
+  const templateKeys = new Set(templates.map((t) => `#build/${t.filename}`));
+  return {
+    name: "nuxt:ui:templates",
+    enforce: "pre",
+    resolveId(id) {
+      if (templateKeys.has(id + ".ts")) {
+        return id.replace("#build/", "virtual:nuxt-ui-templates/") + ".ts";
+      }
+    },
+    loadInclude: (id) => templateKeys.has(id.replace("virtual:nuxt-ui-templates/", "#build/")),
+    load(id) {
+      id = id.replace("virtual:nuxt-ui-templates/", "#build/");
+      return templates.find((t) => `#build/${t.filename}` === id).getContents({});
+    }
+  };
+}
+
+function PluginsPlugin(options) {
+  const plugins = globSync(["**/*", "!*.d.ts"], { cwd: join(runtimeDir, "plugins"), absolute: true });
+  plugins.unshift(resolvePathSync(join(runtimeDir, "vue/plugins/head"), { extensions: [".ts", ".mjs", ".js"] }));
+  if (options.colorMode) {
+    plugins.push(resolvePathSync(join(runtimeDir, "vue/plugins/color-mode"), { extensions: [".ts", ".mjs", ".js"] }));
+  }
+  return {
+    name: "nuxt:ui:plugins",
+    enforce: "pre",
+    resolveId(id) {
+      if (id === "@nuxt/ui/vue-plugin") {
+        return "virtual:nuxt-ui-plugins";
+      }
+    },
+    transform(code, id) {
+      if (plugins.some((p) => id.startsWith(p)) && code.includes("import.meta.client")) {
+        const s = new MagicString(code);
+        s.replaceAll("import.meta.client", "true");
+        if (s.hasChanged()) {
+          return {
+            code: s.toString(),
+            map: s.generateMap({ hires: true })
+          };
+        }
+      }
+    },
+    loadInclude: (id) => id === "virtual:nuxt-ui-plugins",
+    load() {
+      return `
+        ${plugins.map((p) => `import ${genSafeVariableName(p)} from "${p}"`).join("\n")}
+export default {
+  install (app) {
+${plugins.map((p) => `    app.use(${genSafeVariableName(p)})`).join("\n")}
+  }
+}
+        `;
+    }
+  };
+}
+
+function AppConfigPlugin(options, appConfig) {
+  return {
+    name: "nuxt:ui:app-config",
+    enforce: "pre",
+    resolveId(id) {
+      if (id === "#build/app.config") {
+        return "virtual:nuxt-ui-app-config";
+      }
+    },
+    loadInclude: (id) => id === "virtual:nuxt-ui-app-config",
+    load() {
+      return `
+          export default ${JSON.stringify(appConfig)}
+        `;
+    }
+  };
+}
+
+function ComponentImportPlugin(framework, options) {
+  const components = globSync("**/*.vue", { cwd: join(runtimeDir, "components") });
+  const componentNames = new Set(components.map((c) => `${options.prefix}${c.replace(/\.vue$/, "")}`));
+  const overrides = globSync("**/*.vue", { cwd: join(runtimeDir, "vue/components") });
+  const overrideNames = new Set(overrides.map((c) => `${options.prefix}${c.replace(/\.vue$/, "")}`));
+  return [
+    /**
+     * This plugin aims to ensure we override certain components with Vue-compatible versions:
+     * <UIcon> and <ULink> currently.
+     */
+    {
+      name: "nuxt:ui:components",
+      enforce: "pre",
+      resolveId(id, importer) {
+        if (!importer || !normalize(importer).includes(runtimeDir)) {
+          return;
+        }
+        if (!RELATIVE_IMPORT_RE.test(id)) {
+          return;
+        }
+        const filename = id.match(/([^/]+)\.vue$/)?.[1];
+        if (filename && overrideNames.has(`${options.prefix}${filename}`)) {
+          return join(runtimeDir, "vue/components", `${filename}.vue`);
+        }
+      }
+    },
+    AutoImportComponents[framework]({
+      dts: options.dts ?? true,
+      exclude: [/[\\/]node_modules[\\/](?!\.pnpm|@nuxt\/ui)/, /[\\/]\.git[\\/]/, /[\\/]\.nuxt[\\/]/],
+      resolvers: [
+        (componentName) => {
+          if (overrideNames.has(componentName))
+            return { name: "default", from: join(runtimeDir, "vue/components", `${componentName.slice(options.prefix.length)}.vue`) };
+          if (componentNames.has(componentName))
+            return { name: "default", from: join(runtimeDir, "components", `${componentName.slice(options.prefix.length)}.vue`) };
+        }
+      ]
+    })
+  ];
+}
+const RELATIVE_IMPORT_RE = /^\.{1,2}\//;
+
+function NuxtEnvironmentPlugin() {
+  const stubPath = resolvePathSync(join(runtimeDir, "vue/stubs"), { extensions: [".ts", ".mjs", ".js"] });
+  return {
+    name: "nuxt:ui",
+    enforce: "pre",
+    resolveId(id) {
+      if (id === "#imports") {
+        return stubPath;
+      }
+    },
+    transformInclude(id) {
+      return normalize(id).includes(runtimeDir);
+    },
+    transform(code) {
+      if (code.includes("import.meta.client")) {
+        const s = new MagicString(code);
+        s.replaceAll("import.meta.client", "true");
+        if (s.hasChanged()) {
+          return {
+            code: s.toString(),
+            map: s.generateMap({ hires: true })
+          };
+        }
+      }
+    }
+  };
+}
+
+const runtimeDir = fileURLToPath(new URL("./runtime", import.meta.url));
+const NuxtUIPlugin = createUnplugin((_options = {}, meta) => {
+  const options = defu(_options, { fonts: false, devtools: { enabled: false } }, defaultOptions);
+  options.theme = options.theme || {};
+  options.theme.colors = resolveColors(options.theme.colors);
+  const appConfig = defu({ ui: options.ui }, { ui: getDefaultUiConfig(options.theme.colors) });
+  return [
+    NuxtEnvironmentPlugin(),
+    ...ComponentImportPlugin(meta.framework, options),
+    AutoImport[meta.framework]({ dts: options.dts ?? true, dirs: [join(runtimeDir, "composables")] }),
+    tailwind(),
+    PluginsPlugin(options),
+    TemplatePlugin(options, appConfig),
+    AppConfigPlugin(options, appConfig)
+  ];
+});
+
+export { NuxtUIPlugin, runtimeDir };

package/dist/vite.cjs

@@ -0,0 +1,22 @@
+'use strict';
+
+const unplugin = require('./unplugin.cjs');
+require('node:url');
+require('pathe');
+require('unplugin');
+require('unplugin-auto-import');
+require('defu');
+require('@tailwindcss/vite');
+require('./shared/ui.BPnAe4QS.cjs');
+require('../dist/runtime/utils/index.js');
+require('scule');
+require('@nuxt/kit');
+require('tinyglobby');
+require('knitwork');
+require('magic-string');
+require('mlly');
+require('unplugin-vue-components');
+
+const vite = unplugin.NuxtUIPlugin.vite;
+
+module.exports = vite;

package/dist/vite.d.cts

@@ -0,0 +1,13 @@
+import * as vite from 'vite';
+import { NuxtUIOptions } from './unplugin.cjs';
+import 'unplugin';
+import 'tailwindcss/colors';
+import '#build/ui';
+import './module.cjs';
+import '@nuxt/schema';
+import '../dist/runtime/types/index.js';
+import '../dist/runtime/types/utils.js';
+
+declare const _default: (options?: NuxtUIOptions | undefined) => vite.Plugin<any> | vite.Plugin<any>[];
+
+export { NuxtUIOptions, _default as default };

package/dist/vite.d.mts

@@ -0,0 +1,13 @@
+import * as vite from 'vite';
+import { NuxtUIOptions } from './unplugin.mjs';
+import 'unplugin';
+import 'tailwindcss/colors';
+import '#build/ui';
+import './module.mjs';
+import '@nuxt/schema';
+import '../dist/runtime/types/index.js';
+import '../dist/runtime/types/utils.js';
+
+declare const _default: (options?: NuxtUIOptions | undefined) => vite.Plugin<any> | vite.Plugin<any>[];
+
+export { NuxtUIOptions, _default as default };

package/dist/vite.d.ts

@@ -0,0 +1,13 @@
+import * as vite from 'vite';
+import { NuxtUIOptions } from './unplugin.js';
+import 'unplugin';
+import 'tailwindcss/colors';
+import '#build/ui';
+import './module.js';
+import '@nuxt/schema';
+import '../dist/runtime/types/index.js';
+import '../dist/runtime/types/utils.js';
+
+declare const _default: (options?: NuxtUIOptions | undefined) => vite.Plugin<any> | vite.Plugin<any>[];
+
+export { NuxtUIOptions, _default as default };

package/dist/vite.mjs

@@ -0,0 +1,20 @@
+import { NuxtUIPlugin } from './unplugin.mjs';
+import 'node:url';
+import 'pathe';
+import 'unplugin';
+import 'unplugin-auto-import';
+import 'defu';
+import '@tailwindcss/vite';
+import './shared/ui.d52SSCwA.mjs';
+import '../dist/runtime/utils/index.js';
+import 'scule';
+import '@nuxt/kit';
+import 'tinyglobby';
+import 'knitwork';
+import 'magic-string';
+import 'mlly';
+import 'unplugin-vue-components';
+
+const vite = NuxtUIPlugin.vite;
+
+export { vite as default };