@nuxt/kit 0.8.1-edge → 3.0.0-rc.0

package/README.md

@@ -1,5 +1,5 @@
-# `@nuxt/kit`
+# Nuxt Kit
 
-<a href="https://www.npmjs.com/package/@nuxt/kit-edge"><img src="https://flat.badgen.net/npm/v/@nuxt/kit-edge"></a>
+> Toolkit for authoring Nuxt Modules
 
-This is stub package for `@nuxt/kit-edge`. See https://github.com/nuxt/nuxt3-stubs for more information.
+Learn more about this package: <https://v3.nuxtjs.org>

package/dist/index.d.ts

@@ -0,0 +1,291 @@
+import { Nuxt, ModuleContainer, ModuleOptions, ModuleDefinition, NuxtModule, NuxtConfig, NuxtOptions, NuxtCompatibility, NuxtCompatibilityIssues, ComponentsDir, Component, NuxtHooks, NuxtPlugin, NuxtPluginTemplate, NuxtTemplate } from '@nuxt/schema';
+import { LoadConfigOptions } from 'c12';
+import { Import } from 'unimport';
+import { Configuration, WebpackPluginInstance } from 'webpack';
+import { UserConfig, Plugin } from 'vite';
+import * as unctx from 'unctx';
+import { Middleware } from 'h3';
+import * as consola from 'consola';
+
+declare function useModuleContainer(nuxt?: Nuxt): ModuleContainer;
+
+/**
+ * Define a Nuxt module, automatically merging defaults with user provided options, installing
+ * any hooks that are provided, and calling an optional setup function for full control.
+ */
+declare function defineNuxtModule<OptionsT extends ModuleOptions>(definition: ModuleDefinition<OptionsT>): NuxtModule<OptionsT>;
+
+/** Installs a module on a Nuxt instance. */
+declare function installModule(moduleToInstall: string | NuxtModule, _inlineOptions?: any, _nuxt?: Nuxt): Promise<void>;
+
+interface LoadNuxtConfigOptions extends LoadConfigOptions<NuxtConfig> {
+}
+declare function loadNuxtConfig(opts: LoadNuxtConfigOptions): Promise<NuxtOptions>;
+
+interface LoadNuxtOptions extends LoadNuxtConfigOptions {
+    /** Load nuxt with development mode */
+    dev?: boolean;
+    /** Use lazy initialization of nuxt if set to false */
+    ready?: boolean;
+    /** @deprecated Use cwd option */
+    rootDir?: LoadNuxtConfigOptions['cwd'];
+    /** @deprecated use overrides option */
+    config?: LoadNuxtConfigOptions['overrides'];
+}
+declare function loadNuxt(opts: LoadNuxtOptions): Promise<Nuxt>;
+declare function buildNuxt(nuxt: Nuxt): Promise<any>;
+
+declare function addAutoImport(imports: Import | Import[]): void;
+declare function addAutoImportDir(_autoImportDirs: string | string[]): void;
+
+interface ExtendConfigOptions {
+    /**
+     * Install plugin on dev
+     *
+     * @default true
+     */
+    dev?: boolean;
+    /**
+     * Install plugin on build
+     *
+     * @default true
+     */
+    build?: boolean;
+}
+interface ExtendWebpackConfigOptions extends ExtendConfigOptions {
+    /**
+     * Install plugin on server side
+     *
+     * @default true
+     */
+    server?: boolean;
+    /**
+     * Install plugin on client side
+     *
+     * @default true
+     */
+    client?: boolean;
+    /**
+     * Install plugin on modern build
+     *
+     * @default true
+     * @deprecated Nuxt 2 only
+     */
+    modern?: boolean;
+}
+interface ExtendViteConfigOptions extends ExtendConfigOptions {
+}
+/**
+ * Extend Webpack config
+ *
+ * The fallback function might be called multiple times
+ * when applying to both client and server builds.
+ */
+declare function extendWebpackConfig(fn: ((config: Configuration) => void), options?: ExtendWebpackConfigOptions): void;
+/**
+ * Extend Vite config
+ */
+declare function extendViteConfig(fn: ((config: UserConfig) => void), options?: ExtendViteConfigOptions): void;
+/**
+ * Append Webpack plugin to the config.
+ */
+declare function addWebpackPlugin(plugin: WebpackPluginInstance, options?: ExtendWebpackConfigOptions): void;
+/**
+ * Append Vite plugin to the config.
+ */
+declare function addVitePlugin(plugin: Plugin, options?: ExtendViteConfigOptions): void;
+
+/**
+ * Check version constraints and return incompatibility issues as an array
+ */
+declare function checkNuxtCompatibility(constraints: NuxtCompatibility, nuxt?: Nuxt): Promise<NuxtCompatibilityIssues>;
+/**
+ * Check version constraints and throw a detailed error if has any, otherwise returns true
+ */
+declare function assertNuxtCompatibility(constraints: NuxtCompatibility, nuxt?: Nuxt): Promise<true>;
+/**
+ * Check version constraints and return true if passed, otherwise returns false
+ */
+declare function hasNuxtCompatibility(constraints: NuxtCompatibility, nuxt?: Nuxt): Promise<boolean>;
+/**
+ * Check if current nuxt instance is version 2 legacy
+ */
+declare function isNuxt2(nuxt?: Nuxt): any;
+/**
+ * Check if current nuxt instance is version 3
+ */
+declare function isNuxt3(nuxt?: Nuxt): any;
+/**
+ * Get nuxt version
+ */
+declare function getNuxtVersion(nuxt?: Nuxt | any): any;
+
+/**
+ * Register a directory to be scanned for components and imported only when used.
+ *
+ * Requires Nuxt 2.13+
+ */
+declare function addComponentsDir(dir: ComponentsDir): Promise<void>;
+declare type AddComponentOptions = {
+    name: string;
+    filePath: string;
+} & Partial<Exclude<Component, 'shortPath' | 'async' | 'level' | 'import' | 'asyncImport'>>;
+/**
+ * Register a directory to be scanned for components and imported only when used.
+ *
+ * Requires Nuxt 2.13+
+ */
+declare function addComponent(opts: AddComponentOptions): Promise<void>;
+
+/** Direct access to the Nuxt context - see https://github.com/unjs/unctx. */
+declare const nuxtCtx: unctx.UseContext<Nuxt>;
+/**
+ * Get access to Nuxt instance.
+ *
+ * Throws an error if Nuxt instance is unavailable.
+ *
+ * @example
+ * ```js
+ * const nuxt = useNuxt()
+ * ```
+ */
+declare function useNuxt(): Nuxt;
+/**
+ * Get access to Nuxt instance.
+ *
+ * Returns null if Nuxt instance is unavailable.
+ *
+ * @example
+ * ```js
+ * const nuxt = tryUseNuxt()
+ * if (nuxt) {
+ *  // Do something
+ * }
+ * ```
+ */
+declare function tryUseNuxt(): Nuxt | null;
+
+/**
+ * Return a filter function to filter an array of paths
+ */
+declare function isIgnored(pathname: string): boolean;
+
+declare function extendPages(cb: NuxtHooks['pages:extend']): void;
+
+/**
+ * Normalize a nuxt plugin object
+ */
+declare function normalizePlugin(plugin: NuxtPlugin | string): NuxtPlugin;
+/**
+ * Registers a nuxt plugin and to the plugins array.
+ *
+ * Note: You can use mode or .client and .server modifiers with fileName option
+ * to use plugin only in client or server side.
+ *
+ * Note: By default plugin is prepended to the plugins array. You can use second argument to append (push) instead.
+ *
+ * @example
+ * ```js
+ * addPlugin({
+ *   src: path.resolve(__dirname, 'templates/foo.js'),
+ *   filename: 'foo.server.js' // [optional] only include in server bundle
+ * })
+ * ```
+ */
+interface AddPluginOptions {
+    append?: boolean;
+}
+declare function addPlugin(_plugin: NuxtPlugin | string, opts?: AddPluginOptions): NuxtPlugin;
+/**
+ * Adds a template and registers as a nuxt plugin.
+ */
+declare function addPluginTemplate(plugin: NuxtPluginTemplate | string, opts?: AddPluginOptions): NuxtPlugin;
+
+interface ResolvePathOptions {
+    /** Base for resolving paths from. Default is Nuxt rootDir. */
+    cwd?: string;
+    /** An object of aliases. Default is Nuxt configured aliases. */
+    alias?: Record<string, string>;
+    /** The file extensions to try. Default is Nuxt configured extensions. */
+    extensions?: string[];
+}
+/**
+ * Resolve full path to a file or directory respecting Nuxt alias and extensions options
+ *
+ * If path could not be resolved, normalized input path will be returned
+ */
+declare function resolvePath(path: string, opts?: ResolvePathOptions): Promise<string>;
+/**
+ * Try to resolve first existing file in paths
+ */
+declare function findPath(paths: string | string[], opts?: ResolvePathOptions, pathType?: 'file' | 'dir'): Promise<string | null>;
+/**
+ * Resolve path aliases respecting Nuxt alias options
+ */
+declare function resolveAlias(path: string, alias?: Record<string, string>): string;
+interface Resolver {
+    resolve(...path: any[]): string;
+    resolvePath(path: string, opts?: ResolvePathOptions): Promise<string>;
+}
+/**
+ * Create a relative resolver
+ */
+declare function createResolver(base: string | URL): Resolver;
+declare function resolveFiles(path: string, pattern: string | string[]): Promise<string[]>;
+
+interface ServerMiddleware {
+    route?: string;
+    handler: Middleware | string;
+}
+/** Adds a new server middleware to the end of the server middleware array. */
+declare function addServerMiddleware(middleware: ServerMiddleware): void;
+
+/**
+ * Renders given template using lodash template during build into the project buildDir
+ */
+declare function addTemplate(_template: NuxtTemplate | string): NuxtTemplate;
+/**
+ * Normalize a nuxt template object
+ */
+declare function normalizeTemplate(template: NuxtTemplate | string): NuxtTemplate;
+
+declare const logger: consola.Consola;
+declare function useLogger(scope?: string): consola.Consola;
+
+interface ResolveModuleOptions {
+    paths?: string | string[];
+}
+interface RequireModuleOptions extends ResolveModuleOptions {
+    /** Clear the require cache (force fresh require) but only if not within `node_modules` */
+    clearCache?: boolean;
+    /** Automatically de-default the result of requiring the module. */
+    interopDefault?: boolean;
+}
+declare function isNodeModules(id: string): boolean;
+declare function clearRequireCache(id: string): void;
+declare function scanRequireTree(id: string, files?: Set<string>): Set<string>;
+/** Access the require cache by module id. */
+declare function getRequireCacheItem(id: string): NodeModule;
+/** Resolve the `package.json` file for a given module. */
+declare function requireModulePkg(id: string, opts?: RequireModuleOptions): any;
+/** Resolve the path of a module. */
+declare function resolveModule(id: string, opts?: ResolveModuleOptions): string;
+/** Try to resolve the path of a module, but don't emit an error if it can't be found. */
+declare function tryResolveModule(path: string, opts?: ResolveModuleOptions): string | null;
+/** Require a module and return it. */
+declare function requireModule(id: string, opts?: RequireModuleOptions): any;
+declare function importModule(id: string, opts?: RequireModuleOptions): Promise<any>;
+declare function tryImportModule(id: string, opts?: RequireModuleOptions): Promise<any>;
+/** Try to require a module, but don't emit an error if the module can't be required. */
+declare function tryRequireModule(id: string, opts?: RequireModuleOptions): any;
+
+declare function compileTemplate(template: NuxtTemplate, ctx: any): Promise<string>;
+declare const templateUtils: {
+    serialize: (data: any) => string;
+    importName: (src: string) => string;
+    importSources: (sources: string | string[], { lazy }?: {
+        lazy?: boolean;
+    }) => string;
+};
+
+export { AddComponentOptions, AddPluginOptions, ExtendConfigOptions, ExtendViteConfigOptions, ExtendWebpackConfigOptions, LoadNuxtConfigOptions, LoadNuxtOptions, RequireModuleOptions, ResolveModuleOptions, ResolvePathOptions, Resolver, ServerMiddleware, addAutoImport, addAutoImportDir, addComponent, addComponentsDir, addPlugin, addPluginTemplate, addServerMiddleware, addTemplate, addVitePlugin, addWebpackPlugin, assertNuxtCompatibility, buildNuxt, checkNuxtCompatibility, clearRequireCache, compileTemplate, createResolver, defineNuxtModule, extendPages, extendViteConfig, extendWebpackConfig, findPath, getNuxtVersion, getRequireCacheItem, hasNuxtCompatibility, importModule, installModule, isIgnored, isNodeModules, isNuxt2, isNuxt3, loadNuxt, loadNuxtConfig, logger, normalizePlugin, normalizeTemplate, nuxtCtx, requireModule, requireModulePkg, resolveAlias, resolveFiles, resolveModule, resolvePath, scanRequireTree, templateUtils, tryImportModule, tryRequireModule, tryResolveModule, tryUseNuxt, useLogger, useModuleContainer, useNuxt };

package/dist/index.mjs

@@ -0,0 +1,796 @@
+import { parse, basename, resolve, normalize, join, relative, isAbsolute, dirname, extname } from 'pathe';
+import consola from 'consola';
+import { existsSync, readFileSync, promises } from 'node:fs';
+import hash from 'hash-sum';
+import { getContext } from 'unctx';
+import satisfies from 'semver/functions/satisfies.js';
+import { pathToFileURL, fileURLToPath } from 'node:url';
+import { interopDefault } from 'mlly';
+import jiti from 'jiti';
+import { globby } from 'globby';
+import ignore from 'ignore';
+import defu from 'defu';
+import { applyDefaults } from 'untyped';
+import lodashTemplate from 'lodash.template';
+import { camelCase, kebabCase, pascalCase } from 'scule';
+import { genDynamicImport, genImport } from 'knitwork';
+import { loadConfig } from 'c12';
+import { NuxtConfigSchema } from '@nuxt/schema';
+import { resolvePackageJSON, readPackageJSON } from 'pkg-types';
+
+const logger = consola;
+function useLogger(scope) {
+  return scope ? logger.withScope(scope) : logger;
+}
+
+function chainFn(base, fn) {
+  if (typeof fn !== "function") {
+    return base;
+  }
+  return function(...args) {
+    if (typeof base !== "function") {
+      return fn.apply(this, args);
+    }
+    let baseResult = base.apply(this, args);
+    if (baseResult === void 0) {
+      [baseResult] = args;
+    }
+    const fnResult = fn.call(this, baseResult, ...Array.prototype.slice.call(args, 1));
+    if (fnResult === void 0) {
+      return baseResult;
+    }
+    return fnResult;
+  };
+}
+
+const nuxtCtx = getContext("nuxt");
+function useNuxt() {
+  const instance = nuxtCtx.use();
+  if (!instance) {
+    throw new Error("Nuxt instance is unavailable!");
+  }
+  return instance;
+}
+function tryUseNuxt() {
+  return nuxtCtx.use();
+}
+
+function addTemplate(_template) {
+  const nuxt = useNuxt();
+  const template = normalizeTemplate(_template);
+  nuxt.options.build.templates = nuxt.options.build.templates.filter((p) => normalizeTemplate(p).filename !== template.filename);
+  nuxt.options.build.templates.push(template);
+  return template;
+}
+function normalizeTemplate(template) {
+  if (!template) {
+    throw new Error("Invalid template: " + JSON.stringify(template));
+  }
+  if (typeof template === "string") {
+    template = { src: template };
+  } else {
+    template = { ...template };
+  }
+  if (template.src) {
+    if (!existsSync(template.src)) {
+      throw new Error("Template not found: " + template.src);
+    }
+    if (!template.filename) {
+      const srcPath = parse(template.src);
+      template.filename = template.fileName || `${basename(srcPath.dir)}.${srcPath.name}.${hash(template.src)}${srcPath.ext}`;
+    }
+  }
+  if (!template.src && !template.getContents) {
+    throw new Error("Invalid template. Either getContents or src options should be provided: " + JSON.stringify(template));
+  }
+  if (!template.filename) {
+    throw new Error("Invalid template. Either filename should be provided: " + JSON.stringify(template));
+  }
+  if (template.filename.endsWith(".d.ts")) {
+    template.write = true;
+  }
+  if (!template.dst) {
+    const nuxt = useNuxt();
+    template.dst = resolve(nuxt.options.buildDir, template.filename);
+  }
+  return template;
+}
+
+function addServerMiddleware(middleware) {
+  useNuxt().options.serverMiddleware.push(middleware);
+}
+
+async function checkNuxtCompatibility(constraints, nuxt = useNuxt()) {
+  const issues = [];
+  if (constraints.nuxt) {
+    const nuxtVersion = getNuxtVersion(nuxt);
+    const nuxtSemanticVersion = nuxtVersion.split("-").shift();
+    if (!satisfies(nuxtSemanticVersion, constraints.nuxt)) {
+      issues.push({
+        name: "nuxt",
+        message: `Nuxt version \`${constraints.nuxt}\` is required but currently using \`${nuxtVersion}\``
+      });
+    }
+  }
+  if (isNuxt2(nuxt)) {
+    const bridgeRequirement = constraints?.bridge;
+    const hasBridge = !!nuxt.options.bridge;
+    if (bridgeRequirement === true && !hasBridge) {
+      issues.push({
+        name: "bridge",
+        message: "Nuxt bridge is required"
+      });
+    } else if (bridgeRequirement === false && hasBridge) {
+      issues.push({
+        name: "bridge",
+        message: "Nuxt bridge is not supported"
+      });
+    }
+  }
+  await nuxt.callHook("kit:compatibility", constraints, issues);
+  issues.toString = () => issues.map((issue) => ` - [${issue.name}] ${issue.message}`).join("\n");
+  return issues;
+}
+async function assertNuxtCompatibility(constraints, nuxt = useNuxt()) {
+  const issues = await checkNuxtCompatibility(constraints, nuxt);
+  if (issues.length) {
+    throw new Error("Nuxt compatibility issues found:\n" + issues.toString());
+  }
+  return true;
+}
+async function hasNuxtCompatibility(constraints, nuxt = useNuxt()) {
+  const issues = await checkNuxtCompatibility(constraints, nuxt);
+  return !issues.length;
+}
+function isNuxt2(nuxt = useNuxt()) {
+  return getNuxtVersion(nuxt).startsWith("2.");
+}
+function isNuxt3(nuxt = useNuxt()) {
+  return getNuxtVersion(nuxt).startsWith("3.");
+}
+function getNuxtVersion(nuxt = useNuxt()) {
+  const version = (nuxt?._version || nuxt?.version || nuxt?.constructor?.version || "").replace(/^v/g, "");
+  if (!version) {
+    throw new Error("Cannot determine nuxt version! Is currect instance passed?");
+  }
+  return version;
+}
+
+function normalizePlugin(plugin) {
+  if (typeof plugin === "string") {
+    plugin = { src: plugin };
+  } else {
+    plugin = { ...plugin };
+  }
+  if (!plugin.src) {
+    throw new Error("Invalid plugin. src option is required: " + JSON.stringify(plugin));
+  }
+  plugin.src = normalize(plugin.src);
+  if (plugin.ssr) {
+    plugin.mode = "server";
+  }
+  if (!plugin.mode) {
+    const [, mode = "all"] = plugin.src.match(/\.(server|client)(\.\w+)*$/) || [];
+    plugin.mode = mode;
+  }
+  return plugin;
+}
+function addPlugin(_plugin, opts = {}) {
+  const nuxt = useNuxt();
+  const plugin = normalizePlugin(_plugin);
+  nuxt.options.plugins = nuxt.options.plugins.filter((p) => normalizePlugin(p).src !== plugin.src);
+  nuxt.options.plugins[opts.append ? "push" : "unshift"](plugin);
+  return plugin;
+}
+function addPluginTemplate(plugin, opts = {}) {
+  const normalizedPlugin = typeof plugin === "string" ? { src: plugin } : { ...plugin, src: addTemplate(plugin).dst };
+  return addPlugin(normalizedPlugin, opts);
+}
+
+const _require = jiti(process.cwd(), { interopDefault: true });
+function isNodeModules(id) {
+  return /[/\\]node_modules[/\\]/.test(id);
+}
+function clearRequireCache(id) {
+  if (isNodeModules(id)) {
+    return;
+  }
+  const entry = getRequireCacheItem(id);
+  if (!entry) {
+    delete _require.cache[id];
+    return;
+  }
+  if (entry.parent) {
+    entry.parent.children = entry.parent.children.filter((e) => e.id !== id);
+  }
+  for (const child of entry.children) {
+    clearRequireCache(child.id);
+  }
+  delete _require.cache[id];
+}
+function scanRequireTree(id, files = /* @__PURE__ */ new Set()) {
+  if (isNodeModules(id) || files.has(id)) {
+    return files;
+  }
+  const entry = getRequireCacheItem(id);
+  if (!entry) {
+    files.add(id);
+    return files;
+  }
+  files.add(entry.id);
+  for (const child of entry.children) {
+    scanRequireTree(child.id, files);
+  }
+  return files;
+}
+function getRequireCacheItem(id) {
+  try {
+    return _require.cache[id];
+  } catch (e) {
+  }
+}
+function requireModulePkg(id, opts = {}) {
+  return requireModule(join(id, "package.json"), opts);
+}
+function resolveModule(id, opts = {}) {
+  return normalize(_require.resolve(id, {
+    paths: [].concat(global.__NUXT_PREPATHS__, opts.paths, process.cwd(), global.__NUXT_PATHS__).filter(Boolean)
+  }));
+}
+function tryResolveModule(path, opts = {}) {
+  try {
+    return resolveModule(path, opts);
+  } catch (error) {
+    if (error.code !== "MODULE_NOT_FOUND") {
+      throw error;
+    }
+  }
+  return null;
+}
+function requireModule(id, opts = {}) {
+  const resolvedPath = resolveModule(id, opts);
+  if (opts.clearCache && !isNodeModules(id)) {
+    clearRequireCache(resolvedPath);
+  }
+  const requiredModule = _require(resolvedPath);
+  return requiredModule;
+}
+function importModule(id, opts = {}) {
+  const resolvedPath = resolveModule(id, opts);
+  if (opts.interopDefault !== false) {
+    return import(pathToFileURL(resolvedPath).href).then(interopDefault);
+  }
+  return import(pathToFileURL(resolvedPath).href);
+}
+function tryImportModule(id, opts = {}) {
+  try {
+    return importModule(id, opts).catch(() => void 0);
+  } catch {
+  }
+}
+function tryRequireModule(id, opts = {}) {
+  try {
+    return requireModule(id, opts);
+  } catch (e) {
+  }
+}
+
+function isIgnored(pathname) {
+  const nuxt = tryUseNuxt();
+  if (!nuxt) {
+    return null;
+  }
+  if (!nuxt._ignore) {
+    nuxt._ignore = ignore(nuxt.options.ignoreOptions);
+    nuxt._ignore.add(nuxt.options.ignore);
+    const nuxtignoreFile = join(nuxt.options.rootDir, ".nuxtignore");
+    if (existsSync(nuxtignoreFile)) {
+      nuxt._ignore.add(readFileSync(nuxtignoreFile, "utf-8"));
+    }
+  }
+  const relativePath = relative(nuxt.options.rootDir, pathname);
+  if (relativePath.startsWith("..")) {
+    return false;
+  }
+  return relativePath && nuxt._ignore.ignores(relativePath);
+}
+
+async function resolvePath(path, opts = {}) {
+  const _path = path;
+  path = normalize(path);
+  if (isAbsolute(path) && existsSync(path)) {
+    return path;
+  }
+  const nuxt = useNuxt();
+  const cwd = opts.cwd || (nuxt ? nuxt.options.rootDir : process.cwd());
+  const extensions = opts.extensions || (nuxt ? nuxt.options.extensions : [".ts", ".mjs", ".cjs", ".json"]);
+  const modulesDir = nuxt ? nuxt.options.modulesDir : [];
+  path = resolveAlias(path);
+  if (!isAbsolute(path)) {
+    path = resolve(cwd, path);
+  }
+  let isDirectory = false;
+  if (existsSync(path)) {
+    isDirectory = (await promises.lstat(path)).isDirectory();
+    if (!isDirectory) {
+      return path;
+    }
+  }
+  for (const ext of extensions) {
+    const pathWithExt = path + ext;
+    if (existsSync(pathWithExt)) {
+      return pathWithExt;
+    }
+    const pathWithIndex = join(path, "index" + ext);
+    if (isDirectory && existsSync(pathWithIndex)) {
+      return pathWithIndex;
+    }
+  }
+  const resolveModulePath = tryResolveModule(_path, { paths: [cwd, ...modulesDir] });
+  if (resolveModulePath) {
+    return resolveModulePath;
+  }
+  return path;
+}
+async function findPath(paths, opts, pathType = "file") {
+  if (!Array.isArray(paths)) {
+    paths = [paths];
+  }
+  for (const path of paths) {
+    const rPath = await resolvePath(path, opts);
+    if (await existsSensitive(rPath)) {
+      const isDirectory = (await promises.lstat(rPath)).isDirectory();
+      if (!pathType || pathType === "file" && !isDirectory || pathType === "dir" && isDirectory) {
+        return rPath;
+      }
+    }
+  }
+  return null;
+}
+function resolveAlias(path, alias) {
+  if (!alias) {
+    alias = tryUseNuxt()?.options.alias || {};
+  }
+  for (const key in alias) {
+    if (key === "@" && !path.startsWith("@/")) {
+      continue;
+    }
+    if (path.startsWith(key)) {
+      path = alias[key] + path.slice(key.length);
+    }
+  }
+  return path;
+}
+function createResolver(base) {
+  if (!base) {
+    throw new Error("`base` argument is missing for createResolver(base)!");
+  }
+  base = base.toString();
+  if (base.startsWith("file://")) {
+    base = dirname(fileURLToPath(base));
+  }
+  return {
+    resolve: (...path) => resolve(base, ...path),
+    resolvePath: (path, opts) => resolvePath(path, { cwd: base, ...opts })
+  };
+}
+async function existsSensitive(path) {
+  if (!existsSync(path)) {
+    return false;
+  }
+  const dirFiles = await promises.readdir(dirname(path));
+  return dirFiles.includes(basename(path));
+}
+async function resolveFiles(path, pattern) {
+  const files = await globby(pattern, { cwd: path, followSymbolicLinks: true });
+  return files.filter((p) => !isIgnored(p)).map((p) => resolve(path, p));
+}
+
+async function installModule(moduleToInstall, _inlineOptions, _nuxt) {
+  const nuxt = useNuxt();
+  const { nuxtModule, inlineOptions } = await normalizeModule(moduleToInstall, _inlineOptions);
+  await nuxtModule.call(useModuleContainer(), inlineOptions, nuxt);
+  nuxt.options._installedModules = nuxt.options._installedModules || [];
+  nuxt.options._installedModules.push({
+    meta: await nuxtModule.getMeta?.(),
+    entryPath: typeof moduleToInstall === "string" ? resolveAlias(moduleToInstall) : void 0
+  });
+}
+async function normalizeModule(nuxtModule, inlineOptions) {
+  const nuxt = useNuxt();
+  if (nuxtModule?._version || nuxtModule?.version || nuxtModule?.constructor?.version || "") {
+    [nuxtModule, inlineOptions] = [inlineOptions, {}];
+    console.warn(new Error("`installModule` is being called with old signature!"));
+  }
+  if (typeof nuxtModule === "string") {
+    const _src = resolveModule(resolveAlias(nuxtModule), { paths: nuxt.options.modulesDir });
+    const isESM = _src.endsWith(".mjs");
+    nuxtModule = isESM ? await importModule(_src) : requireModule(_src);
+  }
+  if (typeof nuxtModule !== "function") {
+    throw new TypeError("Nuxt module should be a function: " + nuxtModule);
+  }
+  return { nuxtModule, inlineOptions };
+}
+
+const MODULE_CONTAINER_KEY = "__module_container__";
+function useModuleContainer(nuxt = useNuxt()) {
+  if (nuxt[MODULE_CONTAINER_KEY]) {
+    return nuxt[MODULE_CONTAINER_KEY];
+  }
+  async function requireModule(moduleOpts) {
+    let src, inlineOptions;
+    if (typeof moduleOpts === "string") {
+      src = moduleOpts;
+    } else if (Array.isArray(moduleOpts)) {
+      [src, inlineOptions] = moduleOpts;
+    } else if (typeof moduleOpts === "object") {
+      if (moduleOpts.src || moduleOpts.handler) {
+        src = moduleOpts.src || moduleOpts.handler;
+        inlineOptions = moduleOpts.options;
+      } else {
+        src = moduleOpts;
+      }
+    } else {
+      src = moduleOpts;
+    }
+    await installModule(src, inlineOptions);
+  }
+  nuxt[MODULE_CONTAINER_KEY] = {
+    nuxt,
+    options: nuxt.options,
+    ready() {
+      return Promise.resolve();
+    },
+    addVendor() {
+    },
+    requireModule,
+    addModule: requireModule,
+    addServerMiddleware,
+    addTemplate(template) {
+      if (typeof template === "string") {
+        template = { src: template };
+      }
+      if (template.write === void 0) {
+        template.write = true;
+      }
+      return addTemplate(template);
+    },
+    addPlugin(pluginTemplate) {
+      return addPluginTemplate(pluginTemplate);
+    },
+    addLayout(tmpl, name) {
+      const { filename, src } = addTemplate(tmpl);
+      const layoutName = name || parse(src).name;
+      const layout = nuxt.options.layouts[layoutName];
+      if (layout) {
+        logger.warn(`Duplicate layout registration, "${layoutName}" has been registered as "${layout}"`);
+      }
+      nuxt.options.layouts[layoutName] = `./${filename}`;
+      if (name === "error") {
+        this.addErrorLayout(filename);
+      }
+    },
+    addErrorLayout(dst) {
+      const relativeBuildDir = relative(nuxt.options.rootDir, nuxt.options.buildDir);
+      nuxt.options.ErrorPage = `~/${relativeBuildDir}/${dst}`;
+    },
+    extendBuild(fn) {
+      nuxt.options.build.extend = chainFn(nuxt.options.build.extend, fn);
+      if (!isNuxt2(nuxt)) {
+        console.warn("[kit] [compat] Using `extendBuild` in Nuxt 3 has no effect. Instead call extendWebpackConfig and extendViteConfig.");
+      }
+    },
+    extendRoutes(fn) {
+      if (isNuxt2(nuxt)) {
+        nuxt.options.router.extendRoutes = chainFn(nuxt.options.router.extendRoutes, fn);
+      } else {
+        nuxt.hook("pages:extend", async (pages, ...args) => {
+          const maybeRoutes = await fn(pages, ...args);
+          if (maybeRoutes) {
+            console.warn("[kit] [compat] Using `extendRoutes` in Nuxt 3 needs to directly modify first argument instead of returning updated routes. Skipping extended routes.");
+          }
+        });
+      }
+    }
+  };
+  return nuxt[MODULE_CONTAINER_KEY];
+}
+
+async function compileTemplate(template, ctx) {
+  const data = { ...ctx, options: template.options };
+  if (template.src) {
+    try {
+      const srcContents = await promises.readFile(template.src, "utf-8");
+      return lodashTemplate(srcContents, {})(data);
+    } catch (err) {
+      console.error("Error compiling template: ", template);
+      throw err;
+    }
+  }
+  if (template.getContents) {
+    return template.getContents(data);
+  }
+  throw new Error("Invalid template: " + JSON.stringify(template));
+}
+const serialize = (data) => JSON.stringify(data, null, 2).replace(/"{(.+)}"(?=,?$)/gm, (r) => JSON.parse(r).replace(/^{(.*)}$/, "$1"));
+const importName = (src) => `${camelCase(basename(src, extname(src))).replace(/[^a-zA-Z?\d\s:]/g, "")}_${hash(src)}`;
+const importSources = (sources, { lazy = false } = {}) => {
+  if (!Array.isArray(sources)) {
+    sources = [sources];
+  }
+  return sources.map((src) => {
+    if (lazy) {
+      return `const ${importName(src)} = ${genDynamicImport(src, { comment: `webpackChunkName: ${JSON.stringify(src)}` })}`;
+    }
+    return genImport(src, importName(src));
+  }).join("\n");
+};
+const templateUtils = { serialize, importName, importSources };
+
+function defineNuxtModule(definition) {
+  if (typeof definition === "function") {
+    definition = definition(useNuxt());
+    logger.warn("Module definition as function is deprecated and will be removed in the future versions", definition);
+  }
+  if (!definition.meta) {
+    definition.meta = {};
+  }
+  if (!definition.meta.configKey) {
+    definition.meta.name = definition.meta.name || definition.name;
+    definition.meta.configKey = definition.meta.configKey || definition.configKey || definition.meta.name;
+  }
+  function getOptions(inlineOptions, nuxt = useNuxt()) {
+    const configKey = definition.meta.configKey || definition.meta.name;
+    const _defaults = definition.defaults instanceof Function ? definition.defaults(nuxt) : definition.defaults;
+    let _options = defu(inlineOptions, nuxt.options[configKey], _defaults);
+    if (definition.schema) {
+      _options = applyDefaults(definition.schema, _options);
+    }
+    return Promise.resolve(_options);
+  }
+  async function normalizedModule(inlineOptions, nuxt) {
+    if (!nuxt) {
+      nuxt = tryUseNuxt() || this.nuxt;
+    }
+    const uniqueKey = definition.meta.name || definition.meta.configKey;
+    if (uniqueKey) {
+      nuxt.options._requiredModules = nuxt.options._requiredModules || {};
+      if (nuxt.options._requiredModules[uniqueKey]) {
+        return;
+      }
+      nuxt.options._requiredModules[uniqueKey] = true;
+    }
+    if (definition.meta.compatibility) {
+      const issues = await checkNuxtCompatibility(definition.meta.compatibility, nuxt);
+      if (issues.length) {
+        logger.warn(`Module \`${definition.meta.name}\` is disabled due to incompatibility issues:
+${issues.toString()}`);
+        return;
+      }
+    }
+    nuxt2Shims(nuxt);
+    const _options = await getOptions(inlineOptions, nuxt);
+    if (definition.hooks) {
+      nuxt.hooks.addHooks(definition.hooks);
+    }
+    await definition.setup?.call(null, _options, nuxt);
+  }
+  normalizedModule.getMeta = () => Promise.resolve(definition.meta);
+  normalizedModule.getOptions = getOptions;
+  return normalizedModule;
+}
+const NUXT2_SHIMS_KEY = "__nuxt2_shims_key__";
+function nuxt2Shims(nuxt) {
+  if (!isNuxt2(nuxt) || nuxt[NUXT2_SHIMS_KEY]) {
+    return;
+  }
+  nuxt[NUXT2_SHIMS_KEY] = true;
+  nuxt.hooks = nuxt;
+  if (!nuxtCtx.use()) {
+    nuxtCtx.set(nuxt);
+    nuxt.hook("close", () => nuxtCtx.unset());
+  }
+  let virtualTemplates;
+  nuxt.hook("builder:prepared", (_builder, buildOptions) => {
+    virtualTemplates = buildOptions.templates.filter((t) => t.getContents);
+    for (const template of virtualTemplates) {
+      buildOptions.templates.splice(buildOptions.templates.indexOf(template), 1);
+    }
+  });
+  nuxt.hook("build:templates", async (templates) => {
+    const context = {
+      nuxt,
+      utils: templateUtils,
+      app: {
+        dir: nuxt.options.srcDir,
+        extensions: nuxt.options.extensions,
+        plugins: nuxt.options.plugins,
+        templates: [
+          ...templates.templatesFiles,
+          ...virtualTemplates
+        ],
+        templateVars: templates.templateVars
+      }
+    };
+    for await (const template of virtualTemplates) {
+      const contents = await compileTemplate({ ...template, src: "" }, context);
+      await promises.mkdir(dirname(template.dst), { recursive: true });
+      await promises.writeFile(template.dst, contents);
+    }
+  });
+}
+
+async function loadNuxtConfig(opts) {
+  const { config: nuxtConfig, configFile, layers, cwd } = await loadConfig({
+    name: "nuxt",
+    configFile: "nuxt.config",
+    rcFile: ".nuxtrc",
+    dotenv: true,
+    globalRc: true,
+    ...opts
+  });
+  nuxtConfig.rootDir = nuxtConfig.rootDir || cwd;
+  nuxtConfig._nuxtConfigFile = configFile;
+  nuxtConfig._nuxtConfigFiles = [configFile];
+  for (const layer of layers) {
+    layer.config.rootDir = layer.config.rootDir ?? layer.cwd;
+    layer.config.srcDir = resolve(layer.config.rootDir, layer.config.srcDir);
+  }
+  nuxtConfig._layers = layers.filter((layer) => layer.configFile && !layer.configFile.endsWith(".nuxtrc"));
+  return applyDefaults(NuxtConfigSchema, nuxtConfig);
+}
+
+async function loadNuxt(opts) {
+  opts.cwd = opts.cwd || opts.rootDir;
+  opts.overrides = opts.overrides || opts.config || {};
+  const resolveOpts = { paths: opts.cwd };
+  opts.overrides.dev = !!opts.dev;
+  const nearestNuxtPkg = await Promise.all(["nuxt3", "nuxt", "nuxt-edge"].map((pkg2) => resolvePackageJSON(pkg2, { url: opts.cwd }).catch(() => null))).then((r) => r.filter(Boolean).sort((a, b) => b.length - a.length)[0]);
+  if (!nearestNuxtPkg) {
+    throw new Error(`Cannot find any nuxt version from ${opts.cwd}`);
+  }
+  const pkg = await readPackageJSON(nearestNuxtPkg);
+  const majorVersion = parseInt((pkg.version || "").split(".")[0]);
+  if (majorVersion === 3) {
+    const { loadNuxt: loadNuxt3 } = await importModule(pkg._name || pkg.name, resolveOpts);
+    const nuxt2 = await loadNuxt3(opts);
+    return nuxt2;
+  }
+  const { loadNuxt: loadNuxt2 } = await tryImportModule("nuxt-edge", resolveOpts) || await importModule("nuxt", resolveOpts);
+  const nuxt = await loadNuxt2({
+    rootDir: opts.cwd,
+    for: opts.dev ? "dev" : "build",
+    configOverrides: opts.overrides,
+    ready: opts.ready,
+    envConfig: opts.dotenv
+  });
+  return nuxt;
+}
+async function buildNuxt(nuxt) {
+  const resolveOpts = { paths: nuxt.options.rootDir };
+  if (nuxt.options._majorVersion === 3) {
+    const { build: build2 } = await tryImportModule("nuxt3", resolveOpts) || await importModule("nuxt", resolveOpts);
+    return build2(nuxt);
+  }
+  const { build } = await tryImportModule("nuxt-edge", resolveOpts) || await importModule("nuxt", resolveOpts);
+  return build(nuxt);
+}
+
+function addAutoImport(imports) {
+  assertNuxtCompatibility({ bridge: true });
+  useNuxt().hook("autoImports:extend", (autoImports) => {
+    autoImports.push(...Array.isArray(imports) ? imports : [imports]);
+  });
+}
+function addAutoImportDir(_autoImportDirs) {
+  assertNuxtCompatibility({ bridge: true });
+  useNuxt().hook("autoImports:dirs", (autoImportDirs) => {
+    for (const dir of Array.isArray(_autoImportDirs) ? _autoImportDirs : [_autoImportDirs]) {
+      autoImportDirs.push(dir);
+    }
+  });
+}
+
+function extendWebpackConfig(fn, options = {}) {
+  const nuxt = useNuxt();
+  if (options.dev === false && nuxt.options.dev) {
+    return;
+  }
+  if (options.build === false && nuxt.options.build) {
+    return;
+  }
+  nuxt.hook("webpack:config", (configs) => {
+    if (options.server !== false) {
+      const config = configs.find((i) => i.name === "server");
+      if (config) {
+        fn(config);
+      }
+    }
+    if (options.client !== false) {
+      const config = configs.find((i) => i.name === "client");
+      if (config) {
+        fn(config);
+      }
+    }
+    if (options.modern !== false) {
+      const config = configs.find((i) => i.name === "modern");
+      if (config) {
+        fn(config);
+      }
+    }
+  });
+}
+function extendViteConfig(fn, options = {}) {
+  const nuxt = useNuxt();
+  if (options.dev === false && nuxt.options.dev) {
+    return;
+  }
+  if (options.build === false && nuxt.options.build) {
+    return;
+  }
+  nuxt.hook("vite:extend", ({ config }) => fn(config));
+}
+function addWebpackPlugin(plugin, options) {
+  extendWebpackConfig((config) => {
+    config.plugins = config.plugins || [];
+    config.plugins.push(plugin);
+  }, options);
+}
+function addVitePlugin(plugin, options) {
+  extendViteConfig((config) => {
+    config.plugins = config.plugins || [];
+    config.plugins.push(plugin);
+  }, options);
+}
+
+async function addComponentsDir(dir) {
+  const nuxt = useNuxt();
+  await assertNuxtCompatibility({ nuxt: ">=2.13" }, nuxt);
+  nuxt.options.components = nuxt.options.components || [];
+  nuxt.hook("components:dirs", (dirs) => {
+    dirs.push(dir);
+  });
+}
+async function addComponent(opts) {
+  const nuxt = useNuxt();
+  await assertNuxtCompatibility({ nuxt: ">=2.13" }, nuxt);
+  nuxt.options.components = nuxt.options.components || [];
+  const component = {
+    export: opts.export || "default",
+    chunkName: "components/" + kebabCase(opts.name),
+    global: opts.global ?? false,
+    kebabName: kebabCase(opts.name || ""),
+    pascalName: pascalCase(opts.name || ""),
+    prefetch: false,
+    preload: false,
+    mode: "all",
+    shortPath: opts.filePath,
+    async: false,
+    level: 0,
+    asyncImport: `${genDynamicImport(opts.filePath)}.then(r => r['${opts.export || "default"}'])`,
+    import: `require(${JSON.stringify(opts.filePath)})['${opts.export || "default"}']`,
+    ...opts
+  };
+  nuxt.hook("components:extend", (components) => {
+    const existingComponent = components.find((c) => c.pascalName === component.pascalName || c.kebabName === component.kebabName);
+    if (existingComponent) {
+      const name = existingComponent.pascalName || existingComponent.kebabName;
+      console.warn(`Overriding ${name} component.`);
+      Object.assign(existingComponent, component);
+    } else {
+      components.push(component);
+    }
+  });
+}
+
+function extendPages(cb) {
+  const nuxt = useNuxt();
+  if (isNuxt2(nuxt)) {
+    nuxt.hook("build:extendRoutes", cb);
+  } else {
+    nuxt.hook("pages:extend", cb);
+  }
+}
+
+export { addAutoImport, addAutoImportDir, addComponent, addComponentsDir, addPlugin, addPluginTemplate, addServerMiddleware, addTemplate, addVitePlugin, addWebpackPlugin, assertNuxtCompatibility, buildNuxt, checkNuxtCompatibility, clearRequireCache, compileTemplate, createResolver, defineNuxtModule, extendPages, extendViteConfig, extendWebpackConfig, findPath, getNuxtVersion, getRequireCacheItem, hasNuxtCompatibility, importModule, installModule, isIgnored, isNodeModules, isNuxt2, isNuxt3, loadNuxt, loadNuxtConfig, logger, normalizePlugin, normalizeTemplate, nuxtCtx, requireModule, requireModulePkg, resolveAlias, resolveFiles, resolveModule, resolvePath, scanRequireTree, templateUtils, tryImportModule, tryRequireModule, tryResolveModule, tryUseNuxt, useLogger, useModuleContainer, useNuxt };

package/package.json

@@ -1,19 +1,43 @@
 {
   "name": "@nuxt/kit",
-  "version": "0.8.1-edge",
+  "version": "3.0.0-rc.0",
+  "repository": "nuxt/framework",
   "license": "MIT",
-  "main": "./lib/index.mjs",
-  "types": "./lib/index.d.ts",
   "type": "module",
-  "exports": {
-    ".": {
-      "import": "./lib/index.mjs"
-    }
-  },
+  "main": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
   "files": [
-    "lib"
+    "dist"
   ],
+  "scripts": {
+    "prepack": "unbuild"
+  },
   "dependencies": {
-    "@nuxt/kit-edge": "latest"
+    "@nuxt/schema": "3.0.0-rc.0",
+    "c12": "^0.2.5",
+    "consola": "^2.15.3",
+    "defu": "^6.0.0",
+    "globby": "^13.1.1",
+    "hash-sum": "^2.0.0",
+    "ignore": "^5.2.0",
+    "jiti": "^1.13.0",
+    "knitwork": "^0.1.1",
+    "lodash.template": "^4.5.0",
+    "mlly": "^0.5.2",
+    "pathe": "^0.2.0",
+    "pkg-types": "^0.3.2",
+    "scule": "^0.2.1",
+    "semver": "^7.3.7",
+    "unctx": "^1.1.4",
+    "unimport": "^0.1.6",
+    "untyped": "^0.4.4"
+  },
+  "devDependencies": {
+    "@types/lodash.template": "^4",
+    "@types/semver": "^7",
+    "unbuild": "latest"
+  },
+  "engines": {
+    "node": "^14.16.0 || ^16.11.0 || ^17.0.0 || ^18.0.0"
   }
 }

package/lib/index.d.ts

@@ -1 +0,0 @@
-export * from '@nuxt/kit-edge'

package/lib/index.mjs

@@ -1 +0,0 @@
-export * from '@nuxt/kit-edge'