/*!
|
* @nuxt/core v2.15.8 (c) 2016-2021
|
* Released under the MIT License
|
* Repository: https://github.com/nuxt/nuxt.js
|
* Website: https://nuxtjs.org
|
*/
|
'use strict';
|
|
Object.defineProperty(exports, '__esModule', { value: true });
|
|
const path = require('path');
|
const fs = require('fs');
|
const hash = require('hash-sum');
|
const consola = require('consola');
|
const utils = require('@nuxt/utils');
|
const lodash = require('lodash');
|
const Hookable = require('hable');
|
const config = require('@nuxt/config');
|
const server = require('@nuxt/server');
|
const fs$1 = require('fs-extra');
|
|
function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
|
|
const path__default = /*#__PURE__*/_interopDefaultLegacy(path);
|
const fs__default = /*#__PURE__*/_interopDefaultLegacy(fs);
|
const hash__default = /*#__PURE__*/_interopDefaultLegacy(hash);
|
const consola__default = /*#__PURE__*/_interopDefaultLegacy(consola);
|
const Hookable__default = /*#__PURE__*/_interopDefaultLegacy(Hookable);
|
const fs__default$1 = /*#__PURE__*/_interopDefaultLegacy(fs$1);
|
|
class ModuleContainer {
|
constructor (nuxt) {
|
this.nuxt = nuxt;
|
this.options = nuxt.options;
|
this.requiredModules = {};
|
|
// Self bind to allow destructre from container
|
for (const method of Object.getOwnPropertyNames(ModuleContainer.prototype)) {
|
if (typeof this[method] === 'function') {
|
this[method] = this[method].bind(this);
|
}
|
}
|
}
|
|
async ready () {
|
// Call before hook
|
await this.nuxt.callHook('modules:before', this, this.options.modules);
|
|
if (this.options.buildModules && !this.options._start) {
|
// Load every devModule in sequence
|
await utils.sequence(this.options.buildModules, this.addModule);
|
}
|
|
// Load every module in sequence
|
await utils.sequence(this.options.modules, this.addModule);
|
|
// Load ah-hoc modules last
|
await utils.sequence(this.options._modules, this.addModule);
|
|
// Call done hook
|
await this.nuxt.callHook('modules:done', this);
|
}
|
|
addVendor () {
|
consola__default['default'].warn('addVendor has been deprecated due to webpack4 optimization');
|
}
|
|
addTemplate (template) {
|
if (!template) {
|
throw new Error('Invalid template: ' + JSON.stringify(template))
|
}
|
|
// Validate & parse source
|
const src = template.src || template;
|
const srcPath = path__default['default'].parse(src);
|
|
if (typeof src !== 'string' || !fs__default['default'].existsSync(src)) {
|
throw new Error('Template src not found: ' + src)
|
}
|
|
// Mostly for DX, some people prefers `filename` vs `fileName`
|
const fileName = template.fileName || template.filename;
|
// Generate unique and human readable dst filename if not provided
|
const dst = fileName || `${path__default['default'].basename(srcPath.dir)}.${srcPath.name}.${hash__default['default'](src)}${srcPath.ext}`;
|
// Add to templates list
|
const templateObj = {
|
src,
|
dst,
|
options: template.options
|
};
|
|
this.options.build.templates.push(templateObj);
|
|
return templateObj
|
}
|
|
addPlugin (template) {
|
const { dst } = this.addTemplate(template);
|
|
// Add to nuxt plugins
|
this.options.plugins.unshift({
|
src: path__default['default'].join(this.options.buildDir, dst),
|
// TODO: remove deprecated option in Nuxt 3
|
ssr: template.ssr,
|
mode: template.mode
|
});
|
}
|
|
addLayout (template, name) {
|
const { dst, src } = this.addTemplate(template);
|
const layoutName = name || path__default['default'].parse(src).name;
|
const layout = this.options.layouts[layoutName];
|
|
if (layout) {
|
consola__default['default'].warn(`Duplicate layout registration, "${layoutName}" has been registered as "${layout}"`);
|
}
|
|
// Add to nuxt layouts
|
this.options.layouts[layoutName] = `./${dst}`;
|
|
// If error layout, set ErrorPage
|
if (name === 'error') {
|
this.addErrorLayout(dst);
|
}
|
}
|
|
addErrorLayout (dst) {
|
const relativeBuildDir = path__default['default'].relative(this.options.rootDir, this.options.buildDir);
|
this.options.ErrorPage = `~/${relativeBuildDir}/${dst}`;
|
}
|
|
addServerMiddleware (middleware) {
|
this.options.serverMiddleware.push(middleware);
|
}
|
|
extendBuild (fn) {
|
this.options.build.extend = utils.chainFn(this.options.build.extend, fn);
|
}
|
|
extendRoutes (fn) {
|
this.options.router.extendRoutes = utils.chainFn(
|
this.options.router.extendRoutes,
|
fn
|
);
|
}
|
|
requireModule (moduleOpts, { paths } = {}) {
|
return this.addModule(moduleOpts, undefined, { paths })
|
}
|
|
async addModule (moduleOpts, arg2, arg3) {
|
// Arg2 was previously used for requireOnce which is ignored now
|
const { paths } = { ...arg2, ...arg3 };
|
let src;
|
let options;
|
let handler;
|
|
// Type 1: String or Function
|
if (typeof moduleOpts === 'string' || typeof moduleOpts === 'function') {
|
src = moduleOpts;
|
} else if (Array.isArray(moduleOpts)) {
|
// Type 2: Babel style array
|
[src, options] = moduleOpts;
|
} else if (typeof moduleOpts === 'object') {
|
// Type 3: Pure object
|
({ src, options, handler } = moduleOpts);
|
}
|
|
// Define handler if src is a function
|
if (typeof src === 'function') {
|
handler = src;
|
}
|
|
// Prevent adding buildModules-listed entries in production
|
if (this.options.buildModules.includes(handler) && this.options._start) {
|
return
|
}
|
|
// Resolve handler
|
if (!handler) {
|
try {
|
handler = this.nuxt.resolver.requireModule(src, { paths });
|
// pnp support
|
try { (global.__NUXT_PATHS__ || []).push(this.nuxt.resolver.resolvePath(src, { paths })); } catch (_err) {}
|
} catch (error) {
|
if (error.code !== 'MODULE_NOT_FOUND') {
|
throw error
|
}
|
|
// Hint only if entrypoint is not found and src is not local alias or path
|
if (error.message.includes(src) && !/^[~.]|^@\//.test(src)) {
|
let message = 'Module `{name}` not found.';
|
|
if (this.options.buildModules.includes(src)) {
|
message += ' Please ensure `{name}` is in `devDependencies` and installed. HINT: During build step, for npm/yarn, `NODE_ENV=production` or `--production` should NOT be used.'.replace('{name}', src);
|
} else if (this.options.modules.includes(src)) {
|
message += ' Please ensure `{name}` is in `dependencies` and installed.';
|
}
|
|
message = message.replace(/{name}/g, src);
|
|
consola__default['default'].warn(message);
|
}
|
|
if (this.options._cli) {
|
throw error
|
} else {
|
// TODO: Remove in next major version
|
consola__default['default'].warn('Silently ignoring module as programatic usage detected.');
|
return
|
}
|
}
|
}
|
|
// Validate handler
|
if (typeof handler !== 'function') {
|
throw new TypeError('Module should export a function: ' + src)
|
}
|
|
// Ensure module is required once
|
const metaKey = handler.meta && handler.meta.name;
|
const key = metaKey || src;
|
if (typeof key === 'string') {
|
if (this.requiredModules[key]) {
|
if (!metaKey) {
|
// TODO: Skip with nuxt3
|
consola__default['default'].warn('Modules should be only specified once:', key);
|
} else {
|
return
|
}
|
}
|
this.requiredModules[key] = { src, options, handler };
|
}
|
|
// Default module options to empty object
|
if (options === undefined) {
|
options = {};
|
}
|
const result = await handler.call(this, options);
|
return result
|
}
|
}
|
|
var version = "2.15.8";
|
|
class Resolver {
|
constructor (nuxt) {
|
this.nuxt = nuxt;
|
this.options = this.nuxt.options;
|
|
// Binds
|
this.resolvePath = this.resolvePath.bind(this);
|
this.resolveAlias = this.resolveAlias.bind(this);
|
this.resolveModule = this.resolveModule.bind(this);
|
this.requireModule = this.requireModule.bind(this);
|
|
this._createRequire = this.options.createRequire || utils.createRequire;
|
this._require = this._createRequire(__filename);
|
}
|
|
resolveModule (path, { paths } = {}) {
|
try {
|
return this._require.resolve(path, {
|
paths: [].concat(global.__NUXT_PREPATHS__ || [], paths || [], this.options.modulesDir, global.__NUXT_PATHS__ || [], process.cwd())
|
})
|
} catch (error) {
|
if (error.code !== 'MODULE_NOT_FOUND') {
|
throw error
|
}
|
}
|
}
|
|
resolveAlias (path$1) {
|
if (utils.startsWithRootAlias(path$1)) {
|
return path.join(this.options.rootDir, path$1.substr(2))
|
}
|
|
if (utils.startsWithSrcAlias(path$1)) {
|
return path.join(this.options.srcDir, path$1.substr(1))
|
}
|
|
return path.resolve(this.options.srcDir, path$1)
|
}
|
|
resolvePath (path$1, { alias, isAlias = alias, module, isModule = module, isStyle, paths } = {}) {
|
// TODO: Remove in Nuxt 3
|
if (alias) {
|
consola__default['default'].warn('Using alias is deprecated and will be removed in Nuxt 3. Use `isAlias` instead.');
|
}
|
if (module) {
|
consola__default['default'].warn('Using module is deprecated and will be removed in Nuxt 3. Use `isModule` instead.');
|
}
|
|
// Fast return in case of path exists
|
if (fs__default$1['default'].existsSync(path$1)) {
|
return path$1
|
}
|
|
let resolvedPath;
|
|
// Try to resolve it as a regular module
|
if (isModule !== false) {
|
resolvedPath = this.resolveModule(path$1, { paths });
|
}
|
|
// Try to resolve alias
|
if (!resolvedPath && isAlias !== false) {
|
resolvedPath = this.resolveAlias(path$1);
|
}
|
|
// Use path for resolvedPath
|
if (!resolvedPath) {
|
resolvedPath = path$1;
|
}
|
|
let isDirectory;
|
|
// Check if resolvedPath exits and is not a directory
|
if (fs__default$1['default'].existsSync(resolvedPath)) {
|
isDirectory = fs__default$1['default'].lstatSync(resolvedPath).isDirectory();
|
|
if (!isDirectory) {
|
return resolvedPath
|
}
|
}
|
|
const extensions = isStyle ? this.options.styleExtensions : this.options.extensions;
|
|
// Check if any resolvedPath.[ext] or resolvedPath/index.[ext] exists
|
for (const ext of extensions) {
|
if (!isDirectory && fs__default$1['default'].existsSync(resolvedPath + '.' + ext)) {
|
return resolvedPath + '.' + ext
|
}
|
|
const resolvedPathwithIndex = path.join(resolvedPath, 'index.' + ext);
|
if (isDirectory && fs__default$1['default'].existsSync(resolvedPathwithIndex)) {
|
return resolvedPathwithIndex
|
}
|
}
|
|
// If there's no index.[ext] we just return the directory path
|
if (isDirectory) {
|
return resolvedPath
|
}
|
|
// Give up
|
throw new Error(`Cannot resolve "${path$1}" from "${resolvedPath}"`)
|
}
|
|
requireModule (path, { alias, isAlias = alias, intropDefault, interopDefault = intropDefault, paths } = {}) {
|
let resolvedPath = path;
|
let requiredModule;
|
|
// TODO: Remove in Nuxt 3
|
if (intropDefault) {
|
consola__default['default'].warn('Using intropDefault is deprecated and will be removed in Nuxt 3. Use `interopDefault` instead.');
|
}
|
if (alias) {
|
consola__default['default'].warn('Using alias is deprecated and will be removed in Nuxt 3. Use `isAlias` instead.');
|
}
|
|
let lastError;
|
|
// Try to resolve path
|
try {
|
resolvedPath = this.resolvePath(path, { isAlias, paths });
|
} catch (e) {
|
lastError = e;
|
}
|
|
const isExternal = utils.isExternalDependency(resolvedPath);
|
|
// in dev mode make sure to clear the require cache so after
|
// a dev server restart any changed file is reloaded
|
if (this.options.dev && !isExternal) {
|
utils.clearRequireCache(resolvedPath);
|
}
|
|
// Try to require
|
try {
|
requiredModule = this._require(resolvedPath);
|
} catch (e) {
|
lastError = e;
|
}
|
|
// Interop default
|
if (interopDefault !== false && requiredModule && requiredModule.default) {
|
requiredModule = requiredModule.default;
|
}
|
|
// Throw error if failed to require
|
if (requiredModule === undefined && lastError) {
|
throw lastError
|
}
|
|
return requiredModule
|
}
|
}
|
|
class Nuxt extends Hookable__default['default'] {
|
constructor (options = {}) {
|
super(consola__default['default']);
|
|
// Assign options and apply defaults
|
this.options = config.getNuxtConfig(options);
|
|
// Create instance of core components
|
this.resolver = new Resolver(this);
|
this.moduleContainer = new ModuleContainer(this);
|
|
// Deprecated hooks
|
this.deprecateHooks({
|
// #3294 - 7514db73b25c23b8c14ebdafbb4e129ac282aabd
|
'render:context': {
|
to: '_render:context',
|
message: '`render:context(nuxt)` is deprecated, Please use `vue-renderer:ssr:context(context)`'
|
},
|
// #3773
|
'render:routeContext': {
|
to: '_render:context',
|
message: '`render:routeContext(nuxt)` is deprecated, Please use `vue-renderer:ssr:context(context)`'
|
},
|
showReady: 'webpack:done',
|
// Introduced in 2.13
|
'export:done': 'generate:done',
|
'export:before': 'generate:before',
|
'export:extendRoutes': 'generate:extendRoutes',
|
'export:distRemoved': 'generate:distRemoved',
|
'export:distCopied': 'generate:distCopied',
|
'export:route': 'generate:route',
|
'export:routeFailed': 'generate:routeFailed',
|
'export:page': 'generate:page',
|
'export:routeCreated': 'generate:routeCreated'
|
});
|
|
// Add Legacy aliases
|
utils.defineAlias(this, this.resolver, ['resolveAlias', 'resolvePath']);
|
this.showReady = () => { this.callHook('webpack:done'); };
|
|
// Init server
|
if (this.options.server !== false) {
|
this._initServer();
|
}
|
|
// Call ready
|
if (this.options._ready !== false) {
|
this.ready().catch((err) => {
|
consola__default['default'].fatal(err);
|
});
|
}
|
}
|
|
static get version () {
|
return `v${version}` + (global.__NUXT_DEV__ ? '-development' : '')
|
}
|
|
ready () {
|
if (!this._ready) {
|
this._ready = this._init();
|
}
|
return this._ready
|
}
|
|
async _init () {
|
if (this._initCalled) {
|
return this
|
}
|
this._initCalled = true;
|
|
// Add hooks
|
if (lodash.isPlainObject(this.options.hooks)) {
|
this.addHooks(this.options.hooks);
|
} else if (typeof this.options.hooks === 'function') {
|
this.options.hooks(this.hook);
|
}
|
|
// Await for modules
|
await this.moduleContainer.ready();
|
|
// Await for server to be ready
|
if (this.server) {
|
await this.server.ready();
|
}
|
|
// Call ready hook
|
await this.callHook('ready', this);
|
|
return this
|
}
|
|
_initServer () {
|
if (this.server) {
|
return
|
}
|
this.server = new server.Server(this);
|
this.renderer = this.server;
|
this.render = this.server.app;
|
utils.defineAlias(this, this.server, ['renderRoute', 'renderAndGetWindow', 'listen']);
|
}
|
|
async close (callback) {
|
await this.callHook('close', this);
|
|
if (typeof callback === 'function') {
|
await callback();
|
}
|
|
this.clearHooks();
|
}
|
}
|
|
const OVERRIDES = {
|
dry: { dev: false, server: false },
|
dev: { dev: true, _build: true },
|
build: { dev: false, server: false, _build: true },
|
start: { dev: false, _start: true }
|
};
|
|
async function loadNuxt (loadOptions) {
|
// Normalize loadOptions
|
if (typeof loadOptions === 'string') {
|
loadOptions = { for: loadOptions };
|
}
|
const { ready = true } = loadOptions;
|
const _for = loadOptions.for || 'dry';
|
|
// Get overrides
|
const override = OVERRIDES[_for];
|
|
// Unsupported purpose
|
if (!override) {
|
throw new Error('Unsupported for: ' + _for)
|
}
|
|
// Load Config
|
const config$1 = await config.loadNuxtConfig(loadOptions);
|
|
// Apply config overrides
|
Object.assign(config$1, override);
|
|
// Initiate Nuxt
|
const nuxt = new Nuxt(config$1);
|
if (ready) {
|
await nuxt.ready();
|
}
|
|
return nuxt
|
}
|
|
Object.defineProperty(exports, 'loadNuxtConfig', {
|
enumerable: true,
|
get: function () {
|
return config.loadNuxtConfig;
|
}
|
});
|
exports.Module = ModuleContainer;
|
exports.Nuxt = Nuxt;
|
exports.Resolver = Resolver;
|
exports.loadNuxt = loadNuxt;
|
