Big News: Socket raises $60M Series C at a $1B valuation to secure software supply chains for AI-driven development.Announcement →
Sign In

@nuxt/generator

Package Overview
Dependencies
Maintainers
5
Versions
67
Alerts
File Explorer

Advanced tools

License
Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

@nuxt/generator - npm Package Compare versions

Comparing version
2.15.8
 to
2.16.0
+150
-273
dist/generator.js
/*!
* @nuxt/generator v2.15.8 (c) 2016-2021
* @nuxt/generator v2.16.0 (c) 2016-2023
* Released under the MIT License

@@ -9,4 +9,2 @@ * Repository: https://github.com/nuxt/nuxt.js

Object.defineProperty(exports, '__esModule', { value: true });
const path = require('path');

@@ -23,37 +21,24 @@ const chalk = require('chalk');

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) {
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`);
consola.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.staticRoutes = path.resolve(this.options.srcDir, this.options.dir.static);
this.srcBuiltPath = path.resolve(this.options.buildDir, "dist", "client");
this.distPath = this.options.generate.dir;
this.distNuxtPath = path__default['default'].join(
this.distNuxtPath = path.join(
this.distPath,
utils.isUrl(this.options.build.publicPath) ? '' : this.options.build.publicPath
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.staticAssetsDir = path.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, {
this.manifest = defu.defu(manifest, {
routes: []

@@ -63,62 +48,47 @@ });

}
// Shared payload
this._payload = null;
this.setPayload = (payload) => {
this._payload = defu__default['default'](payload, this._payload);
this._payload = defu.defu(payload, this._payload);
};
}
async generate ({ build = true, init = true } = {}) {
consola__default['default'].debug('Initializing generator...');
async generate({ build = true, init = true } = {}) {
consola.debug("Initializing generator...");
await this.initiate({ build, init });
consola__default['default'].debug('Preparing routes for generate...');
consola.debug("Preparing routes for generate...");
const routes = await this.initRoutes();
consola__default['default'].info('Generating pages' + (this.isFullStatic ? ' with full static mode' : ''));
consola.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');
await this.nuxt.callHook("generate:manifest", this.manifest, this);
const manifestPath = path.join(this.staticAssetsDir, "manifest.js");
await fsExtra.ensureDir(this.staticAssetsDir);
await fsExtra.writeFile(manifestPath, `__NUXT_JSONP__("manifest.js", ${devalue(this.manifest)})`, "utf-8");
consola.success("Static manifest generated");
}
// Done hook
await this.nuxt.callHook('generate:done', this, errors);
await this.nuxt.callHook('export:done', this, { errors });
return { errors }
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
async initiate({ build = true, init = true } = {}) {
await this.nuxt.ready();
// Call before hook
await this.nuxt.callHook('generate:before', this, this.options.generate);
await this.nuxt.callHook('export:before', this);
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
if (!this.builder) {
throw new Error(
`Could not generate. Make sure a Builder instance is passed to the constructor of \`Generator\` class or \`getGenerator\` function or disable the build step: \`generate({ build: false })\``
);
}
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'));
const hasBuilt = await fsExtra.exists(path.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\``
)
`No build files found in ${this.srcBuiltPath}.
Please run \`nuxt build\``
);
}
}
// Initialize dist directory
if (init) {

@@ -128,7 +98,5 @@ await this.initDist();

}
async initRoutes (...args) {
// Resolve config.generate.routes promises before generating the routes
async initRoutes(...args) {
let generateRoutes = [];
if (this.options.router.mode !== 'hash') {
if (this.options.router.mode !== "hash") {
try {

@@ -140,10 +108,9 @@ generateRoutes = await utils.promisifyRoute(

} catch (e) {
consola__default['default'].error('Could not resolve routes');
throw e // eslint-disable-line no-unreachable
consola.error("Could not resolve routes");
throw e;
}
}
let routes = [];
// Generate only index.html for router.mode = 'hash' or client-side apps
if (this.options.router.mode === 'hash') {
routes = ['/'];
if (this.options.router.mode === "hash") {
routes = ["/"];
} else {

@@ -153,190 +120,135 @@ try {

} catch (err) {
// Case: where we use custom router.js
// https://github.com/nuxt-community/router-module/issues/83
routes = ['/'];
routes = ["/"];
}
}
routes = routes.filter(route => this.shouldGenerateRoute(route));
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
await this.nuxt.callHook("generate:extendRoutes", routes);
await this.nuxt.callHook("export:extendRoutes", { routes });
return routes;
}
shouldGenerateRoute (route) {
shouldGenerateRoute(route) {
return this.options.generate.exclude.every((regex) => {
if (typeof regex === 'string') {
return regex !== route
if (typeof regex === "string") {
return regex !== route;
}
return !regex.test(route)
})
return !regex.test(route);
});
}
getBuildConfig () {
getBuildConfig() {
try {
return utils.requireModule(path__default['default'].join(this.options.buildDir, 'nuxt/config.json'))
return utils.requireModule(path.join(this.options.buildDir, "nuxt/config.json"));
} catch (err) {
return null
return null;
}
}
getAppRoutes () {
return utils.requireModule(path__default['default'].join(this.options.buildDir, 'routes.json'))
getAppRoutes() {
return utils.requireModule(path.join(this.options.buildDir, "routes.json"));
}
async generateRoutes (routes) {
async generateRoutes(routes) {
const errors = [];
this.routes = [];
this.generatedRoutes = new Set();
this.generatedRoutes = /* @__PURE__ */ 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 });
})
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
return errors;
}
_formatErrors(errors) {
return errors.map(({ type, route, error }) => {
const isHandled = type === "handled";
const color = isHandled ? "yellow" : "red";
let line = chalk[color](` ${route}
_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')
`);
if (isHandled) {
line += chalk.grey(JSON.stringify(error, void 0, 2) + "\n");
} else {
line += chalk.grey(error.stack || error.message || `${error}`);
}
return line;
}).join("\n");
}
async afterGenerate () {
async afterGenerate() {
const { fallback } = this.options.generate;
// Disable SPA fallback if value isn't a non-empty string
if (typeof fallback !== 'string' || !fallback) {
return
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
const fallbackPath = path.join(this.distPath, fallback);
if (await fsExtra.exists(fallbackPath)) {
consola.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('/', {
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');
consola.warn("HTML minification failed for SPA fallback");
}
await fsExtra__default['default'].writeFile(fallbackPath, html, 'utf8');
consola__default['default'].success('Client-side fallback created: `' + fallback + '`');
await fsExtra.writeFile(fallbackPath, html, "utf8");
consola.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);
async initDist() {
await fsExtra.emptyDir(this.distPath);
consola.info(`Generating output directory: ${path.basename(this.distPath)}/`);
await this.nuxt.callHook("generate:distRemoved", this);
await this.nuxt.callHook("export:distRemoved", this);
if (await fsExtra.exists(this.staticRoutes)) {
await fsExtra.copy(this.staticRoutes, this.distPath);
}
// Copy .nuxt/dist/client/ to dist/_nuxt/
await fsExtra__default['default'].copy(this.srcBuiltPath, this.distNuxtPath);
await fsExtra.copy(this.srcBuiltPath, this.distNuxtPath);
if (this.payloadDir) {
await fsExtra__default['default'].ensureDir(this.payloadDir);
await fsExtra.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);
if (this.options.generate.nojekyll) {
const nojekyllPath = path.resolve(this.distPath, ".nojekyll");
await fsExtra.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)
normalizeSlash(route) {
return this.options.router && this.options.router.trailingSlash ? ufo.withTrailingSlash(route) : ufo.withoutTrailingSlash(route);
}
decorateWithPayloads (routes, generateRoutes) {
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),
const path2 = utils.isString(route) ? route : route.route;
routeMap[path2] = {
route: this.normalizeSlash(path2),
payload: route.payload || null
};
});
return Object.values(routeMap)
return Object.values(routeMap);
}
async generateRoute ({ route, payload = {}, errors = [] }) {
async generateRoute({ route, payload = {}, errors = [] }) {
let html;
const pageErrors = [];
route = this.normalizeSlash(route);
const setPayload = (_payload) => {
payload = defu__default['default'](_payload, payload);
payload = defu.defu(_payload, payload);
};
// Apply shared payload
if (this._payload) {
payload = defu__default['default'](payload, this._payload);
payload = defu.defu(payload, this._payload);
}
await this.nuxt.callHook('generate:route', { route, setPayload });
await this.nuxt.callHook('export:route', { route, setPayload });
await this.nuxt.callHook("generate:route", { route, setPayload });
await this.nuxt.callHook("export:route", { route, setPayload });
try {

@@ -349,31 +261,19 @@ const 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();
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)) {
if (foundRoute.startsWith("/") && !foundRoute.startsWith("//") && !path.extname(foundRoute) && this.shouldGenerateRoute(foundRoute) && !this.generatedRoutes.has(foundRoute)) {
this.generatedRoutes.add(foundRoute);
this.routes.push({ route: foundRoute });
}
return null
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');
const assetPath = path.join(this.staticAssetsDir, ufo.decode(asset.path));
await fsExtra.ensureDir(path.dirname(assetPath));
await fsExtra.writeFile(assetPath, asset.src, "utf-8");
}
// Add route to manifest (only if no error and redirect)
if (this.manifest && (!res.error && !res.redirected)) {

@@ -383,18 +283,13 @@ this.manifest.routes.push(ufo.withoutTrailingSlash(route));

}
// SPA fallback
if (res.error) {
pageErrors.push({ type: 'handled', route, error: res.error });
pageErrors.push({ type: "handled", route, error: res.error });
}
} catch (err) {
pageErrors.push({ type: 'unhandled', route, error: 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
await this.nuxt.callHook("generate:routeFailed", { route, errors: pageErrors });
await this.nuxt.callHook("export:routeFailed", { route, errors: pageErrors });
consola.error(this._formatErrors(pageErrors));
return false;
}
try {

@@ -404,19 +299,14 @@ html = this.minifyHtml(html);

const minifyErr = new Error(
`HTML minification failed. Make sure the route generates valid HTML. Failed HTML:\n ${html}`
`HTML minification failed. Make sure the route generates valid HTML. Failed HTML:
${html}`
);
pageErrors.push({ type: 'unhandled', route, error: minifyErr });
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
fileName = route === "/404" ? path.join(path.sep, "404.html") : path.join(route, path.sep, "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');
const normalizedRoute = route.replace(/\/$/, "");
fileName = route.length > 1 ? path.join(path.sep, normalizedRoute + ".html") : path.join(path.sep, "index.html");
}
// Call hook to let user update the path & html
const page = {

@@ -429,48 +319,35 @@ route,

};
page.page = page; // Backward compatibility for export:page hook
await this.nuxt.callHook('generate:page', page);
page.page = page;
await this.nuxt.callHook("generate:page", page);
if (page.exclude) {
return false
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 });
page.path = path.join(this.distPath, page.path);
await fsExtra.mkdirp(path.dirname(page.path));
await fsExtra.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(', ')}`);
consola.error(`Error generating route "${route}": ${pageErrors.map((e) => e.error.message).join(", ")}`);
errors.push(...pageErrors);
} else {
consola__default['default'].success(`Generated route "${route}"`);
consola.success(`Generated route "${route}"`);
}
return true
return true;
}
minifyHtml (html) {
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') {
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!');
consola.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 html;
}
return htmlMinifier__default['default'].minify(html, minificationOptions)
return htmlMinifier.minify(html, minificationOptions);
}
}
function getGenerator (nuxt) {
return new Generator(nuxt)
function getGenerator(nuxt, builder) {
return new Generator(nuxt, builder);
}

@@ -477,0 +354,0 @@ 

+7
-7
package.json
{
"name": "@nuxt/generator",
"version": "2.15.8",
"version": "2.16.0",
"repository": "nuxt/nuxt.js",

@@ -11,11 +11,11 @@ "license": "MIT",

"dependencies": {
"@nuxt/utils": "2.15.8",
"chalk": "^4.1.1",
"@nuxt/utils": "2.16.0",
"chalk": "^4.1.2",
"consola": "^2.15.3",
"defu": "^4.0.1",
"defu": "^6.1.2",
"devalue": "^2.0.1",
"fs-extra": "^9.1.0",
"fs-extra": "^10.1.0",
"html-minifier": "^4.0.0",
"node-html-parser": "^3.2.0",
"ufo": "^0.7.4"
"node-html-parser": "^6.1.4",
"ufo": "^1.0.1"
},

@@ -22,0 +22,0 @@ "publishConfig": {

-16
CHANGELOG.md
# Change Log
All notable changes to this project will be documented in this file.
See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
# [2.15.0](https://github.com/nuxt/nuxt.js/compare/v2.14.12...v2.15.0) (2020-12-17)
### Bug Fixes
* **generator:** ensure manifest dir exists ([#8474](https://github.com/nuxt/nuxt.js/issues/8474)) ([dd7f767](https://github.com/nuxt/nuxt.js/commit/dd7f767d133ca2b21121023f708eac8ffd794ca8))
### Features
* update all dependencies that require node 10.x ([#8346](https://github.com/nuxt/nuxt.js/issues/8346)) ([ab039f0](https://github.com/nuxt/nuxt.js/commit/ab039f051aa379999a00d7b916b7bbdb9305375b))