470 lines
16 KiB
JavaScript
470 lines
16 KiB
JavaScript
/*!
|
|
* @nuxt/generator 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 chalk = require('chalk');
|
|
const consola = require('consola');
|
|
const devalue = require('devalue');
|
|
const fsExtra = require('fs-extra');
|
|
const defu = require('defu');
|
|
const htmlMinifier = require('html-minifier');
|
|
const nodeHtmlParser = require('node-html-parser');
|
|
const ufo = require('ufo');
|
|
const utils = require('@nuxt/utils');
|
|
|
|
function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
|
|
|
|
const path__default = /*#__PURE__*/_interopDefaultLegacy(path);
|
|
const chalk__default = /*#__PURE__*/_interopDefaultLegacy(chalk);
|
|
const consola__default = /*#__PURE__*/_interopDefaultLegacy(consola);
|
|
const devalue__default = /*#__PURE__*/_interopDefaultLegacy(devalue);
|
|
const fsExtra__default = /*#__PURE__*/_interopDefaultLegacy(fsExtra);
|
|
const defu__default = /*#__PURE__*/_interopDefaultLegacy(defu);
|
|
const htmlMinifier__default = /*#__PURE__*/_interopDefaultLegacy(htmlMinifier);
|
|
|
|
class Generator {
|
|
constructor (nuxt, builder) {
|
|
this.nuxt = nuxt;
|
|
this.options = nuxt.options;
|
|
this.builder = builder;
|
|
|
|
// Set variables
|
|
this.isFullStatic = utils.isFullStatic(this.options);
|
|
if (this.isFullStatic) {
|
|
consola__default['default'].info(`Full static generation activated`);
|
|
}
|
|
this.staticRoutes = path__default['default'].resolve(this.options.srcDir, this.options.dir.static);
|
|
this.srcBuiltPath = path__default['default'].resolve(this.options.buildDir, 'dist', 'client');
|
|
this.distPath = this.options.generate.dir;
|
|
this.distNuxtPath = path__default['default'].join(
|
|
this.distPath,
|
|
utils.isUrl(this.options.build.publicPath) ? '' : this.options.build.publicPath
|
|
);
|
|
// Payloads for full static
|
|
if (this.isFullStatic) {
|
|
const { staticAssets, manifest } = this.options.generate;
|
|
this.staticAssetsDir = path__default['default'].resolve(this.distNuxtPath, staticAssets.dir, staticAssets.version);
|
|
this.staticAssetsBase = utils.urlJoin(this.options.app.cdnURL, this.options.generate.staticAssets.versionBase);
|
|
if (manifest) {
|
|
this.manifest = defu__default['default'](manifest, {
|
|
routes: []
|
|
});
|
|
}
|
|
}
|
|
|
|
// Shared payload
|
|
this._payload = null;
|
|
this.setPayload = (payload) => {
|
|
this._payload = defu__default['default'](payload, this._payload);
|
|
};
|
|
}
|
|
|
|
async generate ({ build = true, init = true } = {}) {
|
|
consola__default['default'].debug('Initializing generator...');
|
|
await this.initiate({ build, init });
|
|
|
|
consola__default['default'].debug('Preparing routes for generate...');
|
|
const routes = await this.initRoutes();
|
|
|
|
consola__default['default'].info('Generating pages' + (this.isFullStatic ? ' with full static mode' : ''));
|
|
const errors = await this.generateRoutes(routes);
|
|
|
|
await this.afterGenerate();
|
|
|
|
// Save routes manifest for full static
|
|
if (this.manifest) {
|
|
await this.nuxt.callHook('generate:manifest', this.manifest, this);
|
|
const manifestPath = path__default['default'].join(this.staticAssetsDir, 'manifest.js');
|
|
await fsExtra__default['default'].ensureDir(this.staticAssetsDir);
|
|
await fsExtra__default['default'].writeFile(manifestPath, `__NUXT_JSONP__("manifest.js", ${devalue__default['default'](this.manifest)})`, 'utf-8');
|
|
consola__default['default'].success('Static manifest generated');
|
|
}
|
|
|
|
// Done hook
|
|
await this.nuxt.callHook('generate:done', this, errors);
|
|
await this.nuxt.callHook('export:done', this, { errors });
|
|
|
|
return { errors }
|
|
}
|
|
|
|
async initiate ({ build = true, init = true } = {}) {
|
|
// Wait for nuxt be ready
|
|
await this.nuxt.ready();
|
|
|
|
// Call before hook
|
|
await this.nuxt.callHook('generate:before', this, this.options.generate);
|
|
await this.nuxt.callHook('export:before', this);
|
|
|
|
if (build) {
|
|
// Add flag to set process.static
|
|
this.builder.forGenerate();
|
|
|
|
// Start build process
|
|
await this.builder.build();
|
|
} else {
|
|
const hasBuilt = await fsExtra__default['default'].exists(path__default['default'].resolve(this.options.buildDir, 'dist', 'server', 'client.manifest.json'));
|
|
if (!hasBuilt) {
|
|
throw new Error(
|
|
`No build files found in ${this.srcBuiltPath}.\nPlease run \`nuxt build\``
|
|
)
|
|
}
|
|
}
|
|
|
|
// Initialize dist directory
|
|
if (init) {
|
|
await this.initDist();
|
|
}
|
|
}
|
|
|
|
async initRoutes (...args) {
|
|
// Resolve config.generate.routes promises before generating the routes
|
|
let generateRoutes = [];
|
|
if (this.options.router.mode !== 'hash') {
|
|
try {
|
|
generateRoutes = await utils.promisifyRoute(
|
|
this.options.generate.routes || [],
|
|
...args
|
|
);
|
|
} catch (e) {
|
|
consola__default['default'].error('Could not resolve routes');
|
|
throw e // eslint-disable-line no-unreachable
|
|
}
|
|
}
|
|
let routes = [];
|
|
// Generate only index.html for router.mode = 'hash' or client-side apps
|
|
if (this.options.router.mode === 'hash') {
|
|
routes = ['/'];
|
|
} else {
|
|
try {
|
|
routes = utils.flatRoutes(this.getAppRoutes());
|
|
} catch (err) {
|
|
// Case: where we use custom router.js
|
|
// https://github.com/nuxt-community/router-module/issues/83
|
|
routes = ['/'];
|
|
}
|
|
}
|
|
routes = routes.filter(route => this.shouldGenerateRoute(route));
|
|
routes = this.decorateWithPayloads(routes, generateRoutes);
|
|
|
|
// extendRoutes hook
|
|
await this.nuxt.callHook('generate:extendRoutes', routes);
|
|
await this.nuxt.callHook('export:extendRoutes', { routes });
|
|
|
|
return routes
|
|
}
|
|
|
|
shouldGenerateRoute (route) {
|
|
return this.options.generate.exclude.every((regex) => {
|
|
if (typeof regex === 'string') {
|
|
return regex !== route
|
|
}
|
|
return !regex.test(route)
|
|
})
|
|
}
|
|
|
|
getBuildConfig () {
|
|
try {
|
|
return utils.requireModule(path__default['default'].join(this.options.buildDir, 'nuxt/config.json'))
|
|
} catch (err) {
|
|
return null
|
|
}
|
|
}
|
|
|
|
getAppRoutes () {
|
|
return utils.requireModule(path__default['default'].join(this.options.buildDir, 'routes.json'))
|
|
}
|
|
|
|
async generateRoutes (routes) {
|
|
const errors = [];
|
|
|
|
this.routes = [];
|
|
this.generatedRoutes = new Set();
|
|
|
|
routes.forEach(({ route, ...props }) => {
|
|
route = decodeURI(this.normalizeSlash(route));
|
|
this.routes.push({ route, ...props });
|
|
// Add routes to the tracked generated routes (for crawler)
|
|
this.generatedRoutes.add(route);
|
|
});
|
|
|
|
// Start generate process
|
|
while (this.routes.length) {
|
|
let n = 0;
|
|
await Promise.all(
|
|
this.routes
|
|
.splice(0, this.options.generate.concurrency)
|
|
.map(async ({ route, payload }) => {
|
|
await utils.waitFor(n++ * this.options.generate.interval);
|
|
await this.generateRoute({ route, payload, errors });
|
|
})
|
|
);
|
|
}
|
|
|
|
// Improve string representation for errors
|
|
// TODO: Use consola for more consistency
|
|
errors.toString = () => this._formatErrors(errors);
|
|
|
|
return errors
|
|
}
|
|
|
|
_formatErrors (errors) {
|
|
return errors
|
|
.map(({ type, route, error }) => {
|
|
const isHandled = type === 'handled';
|
|
const color = isHandled ? 'yellow' : 'red';
|
|
|
|
let line = chalk__default['default'][color](` ${route}\n\n`);
|
|
|
|
if (isHandled) {
|
|
line += chalk__default['default'].grey(JSON.stringify(error, undefined, 2) + '\n');
|
|
} else {
|
|
line += chalk__default['default'].grey(error.stack || error.message || `${error}`);
|
|
}
|
|
|
|
return line
|
|
})
|
|
.join('\n')
|
|
}
|
|
|
|
async afterGenerate () {
|
|
const { fallback } = this.options.generate;
|
|
|
|
// Disable SPA fallback if value isn't a non-empty string
|
|
if (typeof fallback !== 'string' || !fallback) {
|
|
return
|
|
}
|
|
|
|
const fallbackPath = path__default['default'].join(this.distPath, fallback);
|
|
|
|
// Prevent conflicts
|
|
if (await fsExtra__default['default'].exists(fallbackPath)) {
|
|
consola__default['default'].warn(`SPA fallback was configured, but the configured path (${fallbackPath}) already exists.`);
|
|
return
|
|
}
|
|
|
|
// Render and write the SPA template to the fallback path
|
|
let { html } = await this.nuxt.server.renderRoute('/', {
|
|
spa: true,
|
|
staticAssetsBase: this.staticAssetsBase
|
|
});
|
|
|
|
try {
|
|
html = this.minifyHtml(html);
|
|
} catch (error) {
|
|
consola__default['default'].warn('HTML minification failed for SPA fallback');
|
|
}
|
|
|
|
await fsExtra__default['default'].writeFile(fallbackPath, html, 'utf8');
|
|
consola__default['default'].success('Client-side fallback created: `' + fallback + '`');
|
|
}
|
|
|
|
async initDist () {
|
|
// Clean destination folder
|
|
await fsExtra__default['default'].emptyDir(this.distPath);
|
|
|
|
consola__default['default'].info(`Generating output directory: ${path__default['default'].basename(this.distPath)}/`);
|
|
await this.nuxt.callHook('generate:distRemoved', this);
|
|
await this.nuxt.callHook('export:distRemoved', this);
|
|
|
|
// Copy static and built files
|
|
if (await fsExtra__default['default'].exists(this.staticRoutes)) {
|
|
await fsExtra__default['default'].copy(this.staticRoutes, this.distPath);
|
|
}
|
|
// Copy .nuxt/dist/client/ to dist/_nuxt/
|
|
await fsExtra__default['default'].copy(this.srcBuiltPath, this.distNuxtPath);
|
|
|
|
if (this.payloadDir) {
|
|
await fsExtra__default['default'].ensureDir(this.payloadDir);
|
|
}
|
|
|
|
// Add .nojekyll file to let GitHub Pages add the _nuxt/ folder
|
|
// https://help.github.com/articles/files-that-start-with-an-underscore-are-missing/
|
|
const nojekyllPath = path__default['default'].resolve(this.distPath, '.nojekyll');
|
|
await fsExtra__default['default'].writeFile(nojekyllPath, '');
|
|
|
|
await this.nuxt.callHook('generate:distCopied', this);
|
|
await this.nuxt.callHook('export:distCopied', this);
|
|
}
|
|
|
|
normalizeSlash (route) {
|
|
return this.options.router && this.options.router.trailingSlash ? ufo.withTrailingSlash(route) : ufo.withoutTrailingSlash(route)
|
|
}
|
|
|
|
decorateWithPayloads (routes, generateRoutes) {
|
|
const routeMap = {};
|
|
// Fill routeMap for known routes
|
|
routes.forEach((route) => {
|
|
routeMap[route] = { route: this.normalizeSlash(route), payload: null };
|
|
});
|
|
// Fill routeMap with given generate.routes
|
|
generateRoutes.forEach((route) => {
|
|
// route is either a string or like { route : '/my_route/1', payload: {} }
|
|
const path = utils.isString(route) ? route : route.route;
|
|
routeMap[path] = {
|
|
route: this.normalizeSlash(path),
|
|
payload: route.payload || null
|
|
};
|
|
});
|
|
return Object.values(routeMap)
|
|
}
|
|
|
|
async generateRoute ({ route, payload = {}, errors = [] }) {
|
|
let html;
|
|
const pageErrors = [];
|
|
|
|
route = this.normalizeSlash(route);
|
|
|
|
const setPayload = (_payload) => {
|
|
payload = defu__default['default'](_payload, payload);
|
|
};
|
|
|
|
// Apply shared payload
|
|
if (this._payload) {
|
|
payload = defu__default['default'](payload, this._payload);
|
|
}
|
|
|
|
await this.nuxt.callHook('generate:route', { route, setPayload });
|
|
await this.nuxt.callHook('export:route', { route, setPayload });
|
|
|
|
try {
|
|
const renderContext = {
|
|
payload,
|
|
staticAssetsBase: this.staticAssetsBase
|
|
};
|
|
const res = await this.nuxt.server.renderRoute(route, renderContext);
|
|
html = res.html;
|
|
|
|
// If crawler activated and called from generateRoutes()
|
|
if (this.options.generate.crawler && this.options.render.ssr) {
|
|
nodeHtmlParser.parse(html).querySelectorAll('a').map((el) => {
|
|
const sanitizedHref = (el.getAttribute('href') || '')
|
|
.replace(this.options.router.base, '/')
|
|
.split('?')[0]
|
|
.split('#')[0]
|
|
.replace(/\/+$/, '')
|
|
.trim();
|
|
|
|
const foundRoute = decodeURI(this.normalizeSlash(sanitizedHref));
|
|
|
|
if (foundRoute.startsWith('/') && !foundRoute.startsWith('//') && !path__default['default'].extname(foundRoute) && this.shouldGenerateRoute(foundRoute) && !this.generatedRoutes.has(foundRoute)) {
|
|
this.generatedRoutes.add(foundRoute);
|
|
this.routes.push({ route: foundRoute });
|
|
}
|
|
return null
|
|
});
|
|
}
|
|
|
|
// Save Static Assets
|
|
if (this.staticAssetsDir && renderContext.staticAssets) {
|
|
for (const asset of renderContext.staticAssets) {
|
|
const assetPath = path__default['default'].join(this.staticAssetsDir, decodeURI(asset.path));
|
|
await fsExtra__default['default'].ensureDir(path__default['default'].dirname(assetPath));
|
|
await fsExtra__default['default'].writeFile(assetPath, asset.src, 'utf-8');
|
|
}
|
|
// Add route to manifest (only if no error and redirect)
|
|
if (this.manifest && (!res.error && !res.redirected)) {
|
|
this.manifest.routes.push(ufo.withoutTrailingSlash(route));
|
|
}
|
|
}
|
|
|
|
// SPA fallback
|
|
if (res.error) {
|
|
pageErrors.push({ type: 'handled', route, error: res.error });
|
|
}
|
|
} catch (err) {
|
|
pageErrors.push({ type: 'unhandled', route, error: err });
|
|
errors.push(...pageErrors);
|
|
|
|
await this.nuxt.callHook('generate:routeFailed', { route, errors: pageErrors });
|
|
await this.nuxt.callHook('export:routeFailed', { route, errors: pageErrors });
|
|
consola__default['default'].error(this._formatErrors(pageErrors));
|
|
|
|
return false
|
|
}
|
|
|
|
try {
|
|
html = this.minifyHtml(html);
|
|
} catch (err) {
|
|
const minifyErr = new Error(
|
|
`HTML minification failed. Make sure the route generates valid HTML. Failed HTML:\n ${html}`
|
|
);
|
|
pageErrors.push({ type: 'unhandled', route, error: minifyErr });
|
|
}
|
|
|
|
let fileName;
|
|
|
|
if (this.options.generate.subFolders) {
|
|
fileName = route === '/404'
|
|
? path__default['default'].join(path__default['default'].sep, '404.html') // /404 -> /404.html
|
|
: path__default['default'].join(route, path__default['default'].sep, 'index.html'); // /about -> /about/index.html
|
|
} else {
|
|
const normalizedRoute = route.replace(/\/$/, '');
|
|
fileName = route.length > 1 ? path__default['default'].join(path__default['default'].sep, normalizedRoute + '.html') : path__default['default'].join(path__default['default'].sep, 'index.html');
|
|
}
|
|
|
|
// Call hook to let user update the path & html
|
|
const page = {
|
|
route,
|
|
path: fileName,
|
|
html,
|
|
exclude: false,
|
|
errors: pageErrors
|
|
};
|
|
page.page = page; // Backward compatibility for export:page hook
|
|
await this.nuxt.callHook('generate:page', page);
|
|
|
|
if (page.exclude) {
|
|
return false
|
|
}
|
|
page.path = path__default['default'].join(this.distPath, page.path);
|
|
|
|
// Make sure the sub folders are created
|
|
await fsExtra__default['default'].mkdirp(path__default['default'].dirname(page.path));
|
|
await fsExtra__default['default'].writeFile(page.path, page.html, 'utf8');
|
|
|
|
await this.nuxt.callHook('generate:routeCreated', { route, path: page.path, errors: pageErrors });
|
|
await this.nuxt.callHook('export:routeCreated', { route, path: page.path, errors: pageErrors });
|
|
|
|
if (pageErrors.length) {
|
|
consola__default['default'].error(`Error generating route "${route}": ${pageErrors.map(e => e.error.message).join(', ')}`);
|
|
errors.push(...pageErrors);
|
|
} else {
|
|
consola__default['default'].success(`Generated route "${route}"`);
|
|
}
|
|
|
|
return true
|
|
}
|
|
|
|
minifyHtml (html) {
|
|
let minificationOptions = this.options.build.html.minify;
|
|
|
|
// Legacy: Override minification options with generate.minify if present
|
|
// TODO: Remove in Nuxt version 3
|
|
if (typeof this.options.generate.minify !== 'undefined') {
|
|
minificationOptions = this.options.generate.minify;
|
|
consola__default['default'].warn('generate.minify has been deprecated and will be removed in the next major version.' +
|
|
' Use build.html.minify instead!');
|
|
}
|
|
|
|
if (!minificationOptions) {
|
|
return html
|
|
}
|
|
|
|
return htmlMinifier__default['default'].minify(html, minificationOptions)
|
|
}
|
|
}
|
|
|
|
function getGenerator (nuxt) {
|
|
return new Generator(nuxt)
|
|
}
|
|
|
|
exports.Generator = Generator;
|
|
exports.getGenerator = getGenerator;
|