1245 lines
33 KiB
JavaScript
1245 lines
33 KiB
JavaScript
const { TemplatePath } = require("@11ty/eleventy-utils");
|
||
const { performance } = require("perf_hooks");
|
||
|
||
const pkg = require("../package.json");
|
||
const TemplateData = require("./TemplateData");
|
||
const TemplateWriter = require("./TemplateWriter");
|
||
const EleventyExtensionMap = require("./EleventyExtensionMap");
|
||
const EleventyErrorHandler = require("./EleventyErrorHandler");
|
||
const EleventyBaseError = require("./EleventyBaseError");
|
||
const EleventyServe = require("./EleventyServe");
|
||
const EleventyWatch = require("./EleventyWatch");
|
||
const EleventyWatchTargets = require("./EleventyWatchTargets");
|
||
const EleventyFiles = require("./EleventyFiles");
|
||
const ConsoleLogger = require("./Util/ConsoleLogger");
|
||
const PathPrefixer = require("./Util/PathPrefixer");
|
||
const TemplateConfig = require("./TemplateConfig");
|
||
const FileSystemSearch = require("./FileSystemSearch");
|
||
const PathNormalizer = require("./Util/PathNormalizer.js");
|
||
const simplePlural = require("./Util/Pluralize");
|
||
const checkPassthroughCopyBehavior = require("./Util/PassthroughCopyBehaviorCheck");
|
||
const debug = require("debug")("Eleventy");
|
||
const eventBus = require("./EventBus");
|
||
|
||
/**
|
||
* @module 11ty/eleventy/Eleventy
|
||
*/
|
||
|
||
/**
|
||
* Runtime of eleventy.
|
||
*
|
||
* @param {String} input - Where to read files from.
|
||
* @param {String} output - Where to write rendered files to.
|
||
* @returns {module:11ty/eleventy/Eleventy~Eleventy}
|
||
*/
|
||
class Eleventy {
|
||
constructor(input, output, options = {}, eleventyConfig = null) {
|
||
if (!eleventyConfig) {
|
||
this.eleventyConfig = new TemplateConfig(null, options.configPath);
|
||
} else {
|
||
this.eleventyConfig = eleventyConfig;
|
||
if (options.configPath) {
|
||
this.eleventyConfig.setProjectConfigPath(options.configPath);
|
||
}
|
||
}
|
||
|
||
this.eleventyConfig.setLogger(this.logger);
|
||
|
||
/**
|
||
* @member {String} - The top level directory the site pretends to reside in
|
||
* @default "/"
|
||
*/
|
||
this.pathPrefix = options.pathPrefix || "/";
|
||
|
||
if (this.pathPrefix || this.pathPrefix === "") {
|
||
this.eleventyConfig.setPathPrefix(this.pathPrefix);
|
||
}
|
||
|
||
/**
|
||
* @member {Object} - Options object passed to the Eleventy constructor
|
||
* @default {}
|
||
*/
|
||
this.options = options;
|
||
|
||
/* Programmatic API config */
|
||
if (options.config && typeof options.config === "function") {
|
||
// TODO use return object here?
|
||
options.config(this.eleventyConfig.userConfig);
|
||
}
|
||
|
||
/**
|
||
* @member {String} - The path to Eleventy's config file.
|
||
* @default null
|
||
*/
|
||
this.configPath = options.configPath;
|
||
|
||
/**
|
||
* @member {String} - Called via CLI (`cli`) or Programmatically (`script`)
|
||
* @default "script"
|
||
*/
|
||
this.source = options.source || "script";
|
||
|
||
/**
|
||
* @member {Boolean} - Running in serverless mode
|
||
* @default false
|
||
*/
|
||
if ("isServerless" in options) {
|
||
this.isServerless = !!options.isServerless;
|
||
} else {
|
||
this.isServerless = !!process.env.AWS_LAMBDA_FUNCTION_NAME;
|
||
}
|
||
|
||
/**
|
||
* @member {String} - One of build, serve, or watch
|
||
* @default "build"
|
||
*/
|
||
this.runMode = options.runMode || "build";
|
||
|
||
/**
|
||
* @member {Object} - Initialize Eleventy environment variables
|
||
* @default null
|
||
*/
|
||
// both this.isServerless and this.runMode need to be set before this
|
||
this.env = this.getEnvironmentVariableValues();
|
||
this.initializeEnvironmentVariables(this.env);
|
||
|
||
/**
|
||
* @member {Object} - Initialize Eleventy’s configuration, including the user config file
|
||
*/
|
||
this.config = this.eleventyConfig.getConfig();
|
||
|
||
/**
|
||
* @member {Object} - Singleton BenchmarkManager instance
|
||
*/
|
||
this.bench = this.config.benchmarkManager;
|
||
|
||
/**
|
||
* @member {Boolean} - Was verbose mode overwritten?
|
||
* @default false
|
||
*/
|
||
this.verboseModeSetViaCommandLineParam = false;
|
||
|
||
/**
|
||
* @member {Boolean} - Is Eleventy running in verbose mode?
|
||
* @default true
|
||
*/
|
||
if (options.quietMode === true || options.quietMode === false) {
|
||
// Set via --quiet
|
||
this.setIsVerbose(!options.quietMode);
|
||
this.verboseModeSetViaCommandLineParam = true;
|
||
} else {
|
||
// Fall back to configuration
|
||
this.setIsVerbose(!this.config.quietMode);
|
||
}
|
||
|
||
/**
|
||
* @member {Boolean} - Is Eleventy running in dry mode?
|
||
* @default false
|
||
*/
|
||
this.isDryRun = false;
|
||
|
||
/**
|
||
* @member {Boolean} - Does the init() method still need to be run (or hasn’t finished yet)
|
||
* @default true
|
||
*/
|
||
this.needsInit = true;
|
||
|
||
/**
|
||
* @member {Boolean} - Explicit input directory (usually used when input is a single file/serverless)
|
||
*/
|
||
if (options.inputDir) {
|
||
this.setInputDir(options.inputDir);
|
||
}
|
||
|
||
if (performance) {
|
||
// TODO this doesn’t reset in serverless mode correctly (cumulative from start of --serve/watch)
|
||
debug("Eleventy warm up time (in ms) %o", performance.now());
|
||
}
|
||
|
||
/** @member {Number} - The timestamp of Eleventy start. */
|
||
this.start = this.getNewTimestamp();
|
||
|
||
/**
|
||
* @member {Array<String>} - Subset of template types.
|
||
* @default null
|
||
*/
|
||
this.formatsOverride = null;
|
||
|
||
/** @member {Object} - tbd. */
|
||
this.eleventyServe = new EleventyServe();
|
||
this.eleventyServe.config = this.config;
|
||
this.eleventyServe.eleventyConfig = this.eleventyConfig;
|
||
|
||
/** @member {String} - Holds the path to the input directory. */
|
||
this.rawInput = input;
|
||
|
||
/** @member {String} - Holds the path to the output directory. */
|
||
this.rawOutput = output;
|
||
|
||
/** @member {Object} - tbd. */
|
||
this.watchManager = new EleventyWatch();
|
||
|
||
/** @member {Object} - tbd. */
|
||
this.watchTargets = new EleventyWatchTargets();
|
||
this.watchTargets.addAndMakeGlob(this.config.additionalWatchTargets);
|
||
this.watchTargets.watchJavaScriptDependencies = this.config.watchJavaScriptDependencies;
|
||
|
||
/** @member {Object} - tbd. */
|
||
this.fileSystemSearch = new FileSystemSearch();
|
||
|
||
this.isIncremental = false;
|
||
this.programmaticApiIncrementalFile = undefined;
|
||
this.isRunInitialBuild = true;
|
||
}
|
||
|
||
getNewTimestamp() {
|
||
if (performance) {
|
||
return performance.now();
|
||
}
|
||
return new Date().getTime();
|
||
}
|
||
|
||
/** @type {String} */
|
||
get input() {
|
||
return this.rawInput || this.config.dir.input;
|
||
}
|
||
|
||
/** @type {String} */
|
||
get inputDir() {
|
||
if (this._inputDir) {
|
||
// set manually via setter
|
||
return this._inputDir;
|
||
}
|
||
|
||
return TemplatePath.getDir(this.input);
|
||
}
|
||
|
||
setInputDir(dir) {
|
||
this._inputDir = dir;
|
||
}
|
||
|
||
/** @type {String} */
|
||
get outputDir() {
|
||
return this.rawOutput || this.config.dir.output;
|
||
}
|
||
|
||
/**
|
||
* Updates the dry-run mode of Eleventy.
|
||
*
|
||
* @method
|
||
* @param {Boolean} isDryRun - Shall Eleventy run in dry mode?
|
||
*/
|
||
setDryRun(isDryRun) {
|
||
this.isDryRun = !!isDryRun;
|
||
}
|
||
|
||
/**
|
||
* Sets the incremental build mode.
|
||
*
|
||
* @method
|
||
* @param {Boolean} isIncremental - Shall Eleventy run in incremental build mode and only write the files that trigger watch updates
|
||
*/
|
||
setIncrementalBuild(isIncremental) {
|
||
this.isIncremental = !!isIncremental;
|
||
this.watchManager.incremental = !!isIncremental;
|
||
}
|
||
|
||
/**
|
||
* Set whether or not to do an initial build
|
||
*
|
||
* @method
|
||
* @param {Boolean} ignoreInitialBuild - Shall Eleventy ignore the default initial build before watching in watch/serve mode?
|
||
* @default true
|
||
*/
|
||
setIgnoreInitial(ignoreInitialBuild) {
|
||
this.isRunInitialBuild = !ignoreInitialBuild;
|
||
}
|
||
|
||
/**
|
||
* Updates the path prefix used in the config.
|
||
*
|
||
* @method
|
||
* @param {String} pathPrefix - The new path prefix.
|
||
*/
|
||
setPathPrefix(pathPrefix) {
|
||
if (pathPrefix || pathPrefix === "") {
|
||
this.eleventyConfig.setPathPrefix(pathPrefix);
|
||
this.config = this.eleventyConfig.getConfig();
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Updates the watch targets.
|
||
*
|
||
* @method
|
||
* @param {} watchTargets - The new watch targets.
|
||
*/
|
||
setWatchTargets(watchTargets) {
|
||
this.watchTargets = watchTargets;
|
||
}
|
||
|
||
/**
|
||
* Restarts Eleventy.
|
||
*
|
||
* @async
|
||
* @method
|
||
*/
|
||
async restart() {
|
||
debug("Restarting");
|
||
this.start = this.getNewTimestamp();
|
||
|
||
this.bench.reset();
|
||
this.eleventyFiles.restart();
|
||
this.extensionMap.reset();
|
||
}
|
||
|
||
/**
|
||
* Logs some statistics after a complete run of Eleventy.
|
||
*
|
||
* @method
|
||
* @returns {String} ret - The log message.
|
||
*/
|
||
logFinished() {
|
||
if (!this.writer) {
|
||
throw new Error(
|
||
"Did you call Eleventy.init to create the TemplateWriter instance? Hint: you probably didn’t."
|
||
);
|
||
}
|
||
|
||
let ret = [];
|
||
|
||
let writeCount = this.writer.getWriteCount();
|
||
let skippedCount = this.writer.getSkippedCount();
|
||
let copyCount = this.writer.getCopyCount();
|
||
|
||
let slashRet = [];
|
||
|
||
if (copyCount) {
|
||
slashRet.push(`Copied ${copyCount} ${simplePlural(copyCount, "file", "files")}`);
|
||
}
|
||
|
||
slashRet.push(
|
||
`Wrote ${writeCount} ${simplePlural(writeCount, "file", "files")}${
|
||
skippedCount ? ` (skipped ${skippedCount})` : ""
|
||
}`
|
||
);
|
||
|
||
if (slashRet.length) {
|
||
ret.push(slashRet.join(" / "));
|
||
}
|
||
|
||
let versionStr = `v${pkg.version}`;
|
||
let time = ((this.getNewTimestamp() - this.start) / 1000).toFixed(2);
|
||
ret.push(`in ${time} ${simplePlural(time, "second", "seconds")}`);
|
||
|
||
if (writeCount >= 10) {
|
||
ret.push(`(${((time * 1000) / writeCount).toFixed(1)}ms each, ${versionStr})`);
|
||
} else {
|
||
ret.push(`(${versionStr})`);
|
||
}
|
||
|
||
return ret.join(" ");
|
||
}
|
||
|
||
_cache(key, inst) {
|
||
if (!this._privateCaches) {
|
||
this._privateCaches = new Map();
|
||
}
|
||
|
||
if (!("caches" in inst)) {
|
||
throw new Error("To use _cache you need a `caches` getter object");
|
||
}
|
||
|
||
// Restore from cache
|
||
if (this._privateCaches.has(key)) {
|
||
let c = this._privateCaches.get(key);
|
||
for (let cacheKey in c) {
|
||
inst[cacheKey] = c[cacheKey];
|
||
}
|
||
} else {
|
||
// Set cache
|
||
let c = {};
|
||
for (let cacheKey of inst.caches || []) {
|
||
c[cacheKey] = inst[cacheKey];
|
||
}
|
||
this._privateCaches.set(key, c);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Starts Eleventy.
|
||
*
|
||
* @async
|
||
* @method
|
||
* @returns {} - tbd.
|
||
*/
|
||
async init(options = {}) {
|
||
options = Object.assign({ viaConfigReset: false }, options);
|
||
|
||
await this.config.events.emit("eleventy.config", this.eleventyConfig);
|
||
|
||
if (this.env) {
|
||
await this.config.events.emit("eleventy.env", this.env);
|
||
}
|
||
|
||
this.config.inputDir = this.inputDir;
|
||
|
||
let formats = this.formatsOverride || this.config.templateFormats;
|
||
this.extensionMap = new EleventyExtensionMap(formats, this.eleventyConfig);
|
||
await this.config.events.emit("eleventy.extensionmap", this.extensionMap);
|
||
|
||
// eleventyServe is always available, even when not in --serve mode
|
||
this.eleventyServe.setOutputDir(this.outputDir);
|
||
|
||
// TODO
|
||
// this.eleventyServe.setWatcherOptions(this.getChokidarConfig());
|
||
|
||
this.templateData = new TemplateData(this.inputDir, this.eleventyConfig);
|
||
this.templateData.extensionMap = this.extensionMap;
|
||
if (this.env) {
|
||
this.templateData.environmentVariables = this.env;
|
||
}
|
||
this.templateData.setFileSystemSearch(this.fileSystemSearch);
|
||
|
||
this.eleventyFiles = new EleventyFiles(
|
||
this.inputDir,
|
||
this.outputDir,
|
||
formats,
|
||
this.eleventyConfig
|
||
);
|
||
this.eleventyFiles.setFileSystemSearch(this.fileSystemSearch);
|
||
this.eleventyFiles.setInput(this.inputDir, this.input);
|
||
this.eleventyFiles.setRunMode(this.runMode);
|
||
this.eleventyFiles.extensionMap = this.extensionMap;
|
||
// This needs to be set before init or it’ll construct a new one
|
||
this.eleventyFiles.templateData = this.templateData;
|
||
this.eleventyFiles.init();
|
||
|
||
if (checkPassthroughCopyBehavior(this.config, this.runMode)) {
|
||
this.eleventyServe.watchPassthroughCopy(
|
||
this.eleventyFiles.getGlobWatcherFilesForPassthroughCopy()
|
||
);
|
||
}
|
||
|
||
this.writer = new TemplateWriter(
|
||
this.inputDir,
|
||
this.outputDir,
|
||
formats,
|
||
this.templateData,
|
||
this.eleventyConfig
|
||
);
|
||
|
||
if (!options.viaConfigReset) {
|
||
this._cache("TemplateWriter", this.writer);
|
||
}
|
||
|
||
this.writer.setInput(this.inputDir, this.input);
|
||
this.writer.logger = this.logger;
|
||
this.writer.extensionMap = this.extensionMap;
|
||
this.writer.setEleventyFiles(this.eleventyFiles);
|
||
|
||
this.writer.setRunInitialBuild(this.isRunInitialBuild);
|
||
this.writer.setIncrementalBuild(this.isIncremental);
|
||
|
||
let dirs = {
|
||
input: this.inputDir,
|
||
data: this.templateData.getDataDir(),
|
||
includes: this.eleventyFiles.getIncludesDir(),
|
||
layouts: this.eleventyFiles.getLayoutsDir(),
|
||
output: this.outputDir,
|
||
};
|
||
|
||
debug(`Directories:
|
||
Input (Dir): ${dirs.input}
|
||
Input (File): ${this.rawInput}
|
||
Data: ${dirs.data}
|
||
Includes: ${dirs.includes}
|
||
Layouts: ${dirs.layouts}
|
||
Output: ${dirs.output}
|
||
Template Formats: ${formats.join(",")}
|
||
Verbose Output: ${this.verboseMode}`);
|
||
|
||
this.writer.setVerboseOutput(this.verboseMode);
|
||
this.writer.setDryRun(this.isDryRun);
|
||
|
||
this.config.events.emit("eleventy.directories", dirs);
|
||
|
||
this.needsInit = false;
|
||
}
|
||
|
||
// These are all set as initial global data under eleventy.env.* (see TemplateData->environmentVariables)
|
||
getEnvironmentVariableValues() {
|
||
let values = {
|
||
source: this.source,
|
||
runMode: this.runMode,
|
||
};
|
||
let configPath = this.eleventyConfig.getLocalProjectConfigFile();
|
||
if (configPath) {
|
||
let absolutePathToConfig = TemplatePath.absolutePath(configPath);
|
||
values.config = absolutePathToConfig;
|
||
|
||
// TODO(zachleat): if config is not in root (e.g. using --config=)
|
||
let root = TemplatePath.getDirFromFilePath(absolutePathToConfig);
|
||
values.root = root;
|
||
}
|
||
|
||
values.source = this.source;
|
||
values.isServerless = this.isServerless;
|
||
|
||
return values;
|
||
}
|
||
|
||
/**
|
||
* Set process.ENV variables for use in Eleventy projects
|
||
*
|
||
* @method
|
||
*/
|
||
initializeEnvironmentVariables(env) {
|
||
process.env.ELEVENTY_ROOT = env.root;
|
||
debug("Setting process.env.ELEVENTY_ROOT: %o", env.root);
|
||
|
||
process.env.ELEVENTY_SOURCE = env.source;
|
||
process.env.ELEVENTY_RUN_MODE = env.runMode;
|
||
|
||
// https://github.com/11ty/eleventy/issues/1957
|
||
// Note: when using --serve, ELEVENTY_SERVERLESS is also set in Serverless.js
|
||
|
||
// Careful here, setting to false will cast to string "false" which is truthy.
|
||
if (env.isServerless) {
|
||
process.env.ELEVENTY_SERVERLESS = true;
|
||
debug("Setting process.env.ELEVENTY_SERVERLESS: %o", true);
|
||
}
|
||
}
|
||
|
||
/* Setter for verbose mode */
|
||
set verboseMode(value) {
|
||
this._isVerboseMode = !!value;
|
||
|
||
if (this.writer) {
|
||
this.writer.setVerboseOutput(this._isVerboseMode);
|
||
}
|
||
|
||
this.bench.setVerboseOutput(this._isVerboseMode);
|
||
|
||
if (this.logger) {
|
||
this.logger.isVerbose = this._isVerboseMode;
|
||
}
|
||
|
||
if (this.errorHandler) {
|
||
this.errorHandler.isVerbose = this._isVerboseMode;
|
||
}
|
||
}
|
||
|
||
/* Getter for verbose mode */
|
||
get verboseMode() {
|
||
return this._isVerboseMode;
|
||
}
|
||
|
||
/* Getter for Logger */
|
||
get logger() {
|
||
if (!this._logger) {
|
||
this._logger = new ConsoleLogger();
|
||
this._logger.isVerbose = this.verboseMode;
|
||
}
|
||
|
||
return this._logger;
|
||
}
|
||
|
||
/* Setter for Logger */
|
||
set logger(logger) {
|
||
this.eleventyConfig.setLogger(logger);
|
||
this._logger = logger;
|
||
}
|
||
|
||
disableLogger() {
|
||
this._logger.overrideLogger(false);
|
||
}
|
||
|
||
/* Getter for error handler */
|
||
get errorHandler() {
|
||
if (!this._errorHandler) {
|
||
this._errorHandler = new EleventyErrorHandler();
|
||
this._errorHandler.isVerbose = this.verboseMode;
|
||
this._errorHandler.logger = this.logger;
|
||
}
|
||
|
||
return this._errorHandler;
|
||
}
|
||
|
||
/**
|
||
* Updates the verbose mode of Eleventy.
|
||
*
|
||
* @method
|
||
* @param {Boolean} isVerbose - Shall Eleventy run in verbose mode?
|
||
*/
|
||
setIsVerbose(isVerbose) {
|
||
// Debug mode should always run quiet (all output goes to debug logger)
|
||
if (process.env.DEBUG) {
|
||
isVerbose = false;
|
||
}
|
||
if (this.logger) {
|
||
this.logger.isVerbose = isVerbose;
|
||
}
|
||
|
||
this.bench.setVerboseOutput(isVerbose);
|
||
this.verboseMode = isVerbose;
|
||
|
||
// Set verbose mode in config file
|
||
this.eleventyConfig.verbose = this.verboseMode;
|
||
}
|
||
|
||
/**
|
||
* Updates the template formats of Eleventy.
|
||
*
|
||
* @method
|
||
* @param {String} formats - The new template formats.
|
||
*/
|
||
setFormats(formats) {
|
||
if (formats && formats !== "*") {
|
||
this.formatsOverride = formats.split(",");
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Updates the run mode of Eleventy.
|
||
*
|
||
* @method
|
||
* @param {String} runMode - One of "build", "watch", or "serve"
|
||
*/
|
||
setRunMode(runMode) {
|
||
this.runMode = runMode;
|
||
}
|
||
|
||
/**
|
||
* Set the file that needs to be rendered/compiled/written for an incremental build.
|
||
* This method is part of the programmatic API and is not used internally.
|
||
*
|
||
* @method
|
||
* @param {String} incrementalFile - File path (added or modified in a project)
|
||
*/
|
||
setIncrementalFile(incrementalFile) {
|
||
if (incrementalFile) {
|
||
// This is used for collections-friendly serverless mode.
|
||
this.setIgnoreInitial(true);
|
||
this.setIncrementalBuild(true);
|
||
|
||
this.programmaticApiIncrementalFile = incrementalFile;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Reads the version of Eleventy.
|
||
*
|
||
* @static
|
||
* @returns {String} - The version of Eleventy.
|
||
*/
|
||
static getVersion() {
|
||
return pkg.version;
|
||
}
|
||
|
||
/**
|
||
* @deprecated since 1.0.1, use static Eleventy.getVersion()
|
||
*/
|
||
getVersion() {
|
||
return Eleventy.getVersion();
|
||
}
|
||
|
||
/**
|
||
* Shows a help message including usage.
|
||
*
|
||
* @static
|
||
* @returns {String} - The help message.
|
||
*/
|
||
static getHelp() {
|
||
return `Usage: eleventy
|
||
eleventy --input=. --output=./_site
|
||
eleventy --serve
|
||
|
||
Arguments:
|
||
|
||
--version
|
||
|
||
--input=.
|
||
Input template files (default: \`.\`)
|
||
|
||
--output=_site
|
||
Write HTML output to this folder (default: \`_site\`)
|
||
|
||
--serve
|
||
Run web server on --port (default 8080) and watch them too
|
||
|
||
--port
|
||
Run the --serve web server on this port (default 8080)
|
||
|
||
--watch
|
||
Wait for files to change and automatically rewrite (no web server)
|
||
|
||
--ignore-initial
|
||
Start without a build; build when files change. Works best with watch/serve/incremental.
|
||
|
||
--formats=liquid,md
|
||
Whitelist only certain template types (default: \`*\`)
|
||
|
||
--quiet
|
||
Don’t print all written files (off by default)
|
||
|
||
--config=filename.js
|
||
Override the eleventy config file path (default: \`.eleventy.js\`)
|
||
|
||
--pathprefix='/'
|
||
Change all url template filters to use this subdirectory.
|
||
|
||
--dryrun
|
||
Don’t write any files. Useful with \`DEBUG=Eleventy* npx eleventy\`
|
||
|
||
--to=json
|
||
--to=ndjson
|
||
Change the output to JSON or NDJSON (default: \`fs\`)
|
||
|
||
--help`;
|
||
}
|
||
|
||
/**
|
||
* @deprecated since 1.0.1, use static Eleventy.getHelp()
|
||
*/
|
||
getHelp() {
|
||
return Eleventy.getHelp();
|
||
}
|
||
|
||
/**
|
||
* Resets the config of Eleventy.
|
||
*
|
||
* @method
|
||
*/
|
||
resetConfig() {
|
||
this.env = this.getEnvironmentVariableValues();
|
||
this.initializeEnvironmentVariables(this.env);
|
||
|
||
this.eleventyConfig.reset();
|
||
|
||
this.config = this.eleventyConfig.getConfig();
|
||
this.eleventyServe.config = this.config;
|
||
this.eleventyServe.eleventyConfig = this.eleventyConfig;
|
||
|
||
// only use config quietMode if --quiet not set on CLI
|
||
if (!this.verboseModeSetViaCommandLineParam) {
|
||
this.setIsVerbose(!this.config.quietMode);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* tbd.
|
||
*
|
||
* @private
|
||
* @method
|
||
* @param {String} changedFilePath - File that triggered a re-run (added or modified)
|
||
*/
|
||
async _addFileToWatchQueue(changedFilePath, isResetConfig) {
|
||
// Currently this is only for 11ty.js deps but should be extended with usesGraph
|
||
let usedByDependants = [];
|
||
if (this.watchTargets) {
|
||
usedByDependants = this.watchTargets.getDependantsOf(
|
||
TemplatePath.addLeadingDotSlash(changedFilePath)
|
||
);
|
||
}
|
||
|
||
// Note: this is a sync event!
|
||
eventBus.emit("eleventy.resourceModified", changedFilePath, usedByDependants, {
|
||
viaConfigReset: isResetConfig,
|
||
});
|
||
|
||
this.watchManager.addToPendingQueue(changedFilePath);
|
||
}
|
||
|
||
shouldTriggerConfigReset(changedFiles) {
|
||
let configFilePaths = new Set(this.eleventyConfig.getLocalProjectConfigFiles());
|
||
for (let filePath of changedFiles) {
|
||
if (configFilePaths.has(filePath)) {
|
||
return true;
|
||
}
|
||
}
|
||
|
||
for (const configFilePath of configFilePaths) {
|
||
// Any dependencies of the config file changed
|
||
let configFileDependencies = new Set(this.watchTargets.getDependenciesOf(configFilePath));
|
||
|
||
for (let filePath of changedFiles) {
|
||
if (configFileDependencies.has(filePath)) {
|
||
return true;
|
||
}
|
||
}
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
// Checks the build queue to see if any configuration related files have changed
|
||
_shouldResetConfig(activeQueue = []) {
|
||
if (!activeQueue.length) {
|
||
return false;
|
||
}
|
||
|
||
return this.shouldTriggerConfigReset(
|
||
activeQueue.map((path) => {
|
||
return PathNormalizer.normalizeSeperator(TemplatePath.addLeadingDotSlash(path));
|
||
})
|
||
);
|
||
}
|
||
|
||
/**
|
||
* tbd.
|
||
*
|
||
* @private
|
||
* @method
|
||
*/
|
||
async _watch(isResetConfig = false) {
|
||
if (this.watchManager.isBuildRunning()) {
|
||
return;
|
||
}
|
||
|
||
this.watchManager.setBuildRunning();
|
||
|
||
let queue = this.watchManager.getActiveQueue();
|
||
await this.config.events.emit("beforeWatch", queue);
|
||
await this.config.events.emit("eleventy.beforeWatch", queue);
|
||
|
||
// Clear `require` cache for all files that triggered the rebuild
|
||
this.watchTargets.clearRequireCacheFor(queue);
|
||
|
||
// reset and reload global configuration
|
||
if (isResetConfig) {
|
||
this.resetConfig();
|
||
}
|
||
|
||
await this.restart();
|
||
await this.init({ viaConfigReset: isResetConfig });
|
||
|
||
let incrementalFile = this.watchManager.getIncrementalFile();
|
||
if (incrementalFile) {
|
||
this.writer.setIncrementalFile(incrementalFile);
|
||
}
|
||
|
||
let writeResults = await this.write();
|
||
let passthroughCopyResults;
|
||
let templateResults;
|
||
if (!writeResults.error) {
|
||
[passthroughCopyResults, ...templateResults] = writeResults;
|
||
}
|
||
|
||
this.writer.resetIncrementalFile();
|
||
|
||
this.watchTargets.reset();
|
||
|
||
await this._initWatchDependencies();
|
||
|
||
// Add new deps to chokidar
|
||
this.watcher.add(this.watchTargets.getNewTargetsSinceLastReset());
|
||
|
||
// Is a CSS input file and is not in the includes folder
|
||
// TODO check output path file extension of this template (not input path)
|
||
// TODO add additional API for this, maybe a config callback?
|
||
let onlyCssChanges = this.watchManager.hasAllQueueFiles((path) => {
|
||
return (
|
||
path.endsWith(".css") &&
|
||
// TODO how to make this work with relative includes?
|
||
!TemplatePath.startsWithSubPath(path, this.eleventyFiles.getIncludesDir())
|
||
);
|
||
});
|
||
|
||
if (writeResults.error) {
|
||
this.eleventyServe.sendError({
|
||
error: writeResults.error,
|
||
});
|
||
} else {
|
||
let normalizedPathPrefix = PathPrefixer.normalizePathPrefix(this.config.pathPrefix);
|
||
await this.eleventyServe.reload({
|
||
files: this.watchManager.getActiveQueue(),
|
||
subtype: onlyCssChanges ? "css" : undefined,
|
||
build: {
|
||
templates: templateResults
|
||
.flat()
|
||
.filter((entry) => !!entry)
|
||
.map((entry) => {
|
||
entry.url = PathPrefixer.joinUrlParts(normalizedPathPrefix, entry.url);
|
||
return entry;
|
||
}),
|
||
},
|
||
});
|
||
}
|
||
|
||
this.watchManager.setBuildFinished();
|
||
|
||
let queueSize = this.watchManager.getPendingQueueSize();
|
||
if (queueSize > 0) {
|
||
this.logger.log(
|
||
`You saved while Eleventy was running, let’s run again. (${queueSize} change${
|
||
queueSize !== 1 ? "s" : ""
|
||
})`
|
||
);
|
||
await this._watch();
|
||
} else {
|
||
this.logger.log("Watching…");
|
||
}
|
||
}
|
||
|
||
/**
|
||
* tbd.
|
||
*
|
||
* @returns {} - tbd.
|
||
*/
|
||
get watcherBench() {
|
||
return this.bench.get("Watcher");
|
||
}
|
||
|
||
/**
|
||
* Set up watchers and benchmarks.
|
||
*
|
||
* @async
|
||
* @method
|
||
*/
|
||
async initWatch() {
|
||
this.watchManager = new EleventyWatch();
|
||
this.watchManager.incremental = this.isIncremental;
|
||
|
||
this.watchTargets.add(["./package.json"]);
|
||
this.watchTargets.add(this.eleventyFiles.getGlobWatcherFiles());
|
||
this.watchTargets.add(this.eleventyFiles.getIgnoreFiles());
|
||
|
||
// Watch the local project config file
|
||
this.watchTargets.add(this.eleventyConfig.getLocalProjectConfigFiles());
|
||
|
||
// Template and Directory Data Files
|
||
this.watchTargets.add(await this.eleventyFiles.getGlobWatcherTemplateDataFiles());
|
||
|
||
let benchmark = this.watcherBench.get(
|
||
"Watching JavaScript Dependencies (disable with `eleventyConfig.setWatchJavaScriptDependencies(false)`)"
|
||
);
|
||
benchmark.before();
|
||
await this._initWatchDependencies();
|
||
benchmark.after();
|
||
}
|
||
|
||
/**
|
||
* Starts watching dependencies.
|
||
*
|
||
* @private
|
||
* @async
|
||
* @method
|
||
*/
|
||
async _initWatchDependencies() {
|
||
if (!this.watchTargets.watchJavaScriptDependencies) {
|
||
return;
|
||
}
|
||
|
||
let dataDir = TemplatePath.stripLeadingDotSlash(this.templateData.getDataDir());
|
||
function filterOutGlobalDataFiles(path) {
|
||
return !dataDir || !TemplatePath.stripLeadingDotSlash(path).startsWith(dataDir);
|
||
}
|
||
|
||
// Template files .11ty.js
|
||
let templateFiles = this.eleventyFiles.getWatchPathCache();
|
||
this.watchTargets.addDependencies(templateFiles);
|
||
|
||
// Config file dependencies
|
||
this.watchTargets.addDependencies(
|
||
this.eleventyConfig.getLocalProjectConfigFiles(),
|
||
filterOutGlobalDataFiles
|
||
);
|
||
|
||
// Deps from Global Data (that aren’t in the global data directory, everything is watched there)
|
||
let globalDataDeps = this.templateData.getWatchPathCache();
|
||
this.watchTargets.addDependencies(globalDataDeps, filterOutGlobalDataFiles);
|
||
|
||
this.watchTargets.addDependencies(
|
||
await this.eleventyFiles.getWatcherTemplateJavaScriptDataFiles()
|
||
);
|
||
}
|
||
|
||
/**
|
||
* Returns all watched files.
|
||
*
|
||
* @async
|
||
* @method
|
||
* @returns {} targets - The watched files.
|
||
*/
|
||
async getWatchedFiles() {
|
||
return this.watchTargets.getTargets();
|
||
}
|
||
|
||
getChokidarConfig() {
|
||
let ignores = this.eleventyFiles.getGlobWatcherIgnores();
|
||
debug("Ignoring watcher changes to: %o", ignores);
|
||
|
||
let configOptions = this.config.chokidarConfig;
|
||
|
||
// can’t override these yet
|
||
// TODO maybe if array, merge the array?
|
||
delete configOptions.ignored;
|
||
|
||
return Object.assign(
|
||
{
|
||
ignored: ignores,
|
||
ignoreInitial: true,
|
||
awaitWriteFinish: {
|
||
stabilityThreshold: 150,
|
||
pollInterval: 25,
|
||
},
|
||
},
|
||
configOptions
|
||
);
|
||
}
|
||
|
||
/**
|
||
* Start the watching of files
|
||
*
|
||
* @async
|
||
* @method
|
||
*/
|
||
async watch() {
|
||
this.watcherBench.setMinimumThresholdMs(500);
|
||
this.watcherBench.reset();
|
||
|
||
// We use a string module name and try/catch here to hide this from the zisi and esbuild serverless bundlers
|
||
let chokidar;
|
||
// eslint-disable-next-line no-useless-catch
|
||
try {
|
||
let moduleName = "chokidar";
|
||
chokidar = require(moduleName);
|
||
} catch (e) {
|
||
throw e;
|
||
}
|
||
|
||
// Note that watching indirectly depends on this for fetching dependencies from JS files
|
||
// See: TemplateWriter:pathCache and EleventyWatchTargets
|
||
let result = await this.write();
|
||
if (result.error) {
|
||
// initial build failed—quit watch early
|
||
return Promise.reject(result.error);
|
||
}
|
||
|
||
let initWatchBench = this.watcherBench.get("Start up --watch");
|
||
initWatchBench.before();
|
||
|
||
await this.initWatch();
|
||
|
||
// TODO improve unwatching if JS dependencies are removed (or files are deleted)
|
||
let rawFiles = await this.getWatchedFiles();
|
||
debug("Watching for changes to: %o", rawFiles);
|
||
|
||
let watcher = chokidar.watch(rawFiles, this.getChokidarConfig());
|
||
|
||
initWatchBench.after();
|
||
|
||
this.watcherBench.finish("Watch");
|
||
|
||
this.logger.forceLog("Watching…");
|
||
|
||
this.watcher = watcher;
|
||
|
||
let watchDelay;
|
||
let watchRun = async (path) => {
|
||
path = TemplatePath.normalize(path);
|
||
try {
|
||
let isResetConfig = this._shouldResetConfig([path]);
|
||
this._addFileToWatchQueue(path, isResetConfig);
|
||
clearTimeout(watchDelay);
|
||
|
||
await new Promise((resolve, reject) => {
|
||
watchDelay = setTimeout(async () => {
|
||
this._watch(isResetConfig).then(resolve, reject);
|
||
}, this.config.watchThrottleWaitTime);
|
||
});
|
||
} catch (e) {
|
||
if (e instanceof EleventyBaseError) {
|
||
this.errorHandler.error(e, "Eleventy watch error");
|
||
this.watchManager.setBuildFinished();
|
||
} else {
|
||
this.errorHandler.fatal(e, "Eleventy fatal watch error");
|
||
this.stopWatch();
|
||
}
|
||
}
|
||
};
|
||
|
||
watcher.on("change", async (path) => {
|
||
this.logger.forceLog(`File changed: ${path}`);
|
||
await watchRun(path);
|
||
});
|
||
|
||
watcher.on("add", async (path) => {
|
||
this.logger.forceLog(`File added: ${path}`);
|
||
this.fileSystemSearch.add(path);
|
||
await watchRun(path);
|
||
});
|
||
|
||
watcher.on("unlink", (path) => {
|
||
// this.logger.forceLog(`File removed: ${path}`);
|
||
this.fileSystemSearch.delete(path);
|
||
});
|
||
|
||
process.on("SIGINT", () => this.stopWatch());
|
||
}
|
||
|
||
stopWatch() {
|
||
debug("Cleaning up chokidar and server instances, if they exist.");
|
||
this.eleventyServe.close();
|
||
this.watcher.close();
|
||
|
||
process.exit();
|
||
}
|
||
|
||
/**
|
||
* Serve Eleventy on this port.
|
||
*
|
||
* @param {Number} port - The HTTP port to serve Eleventy from.
|
||
*/
|
||
async serve(port) {
|
||
// Port is optional and in this case likely via --port on the command line
|
||
// May defer to configuration API options `port` property
|
||
return this.eleventyServe.serve(port);
|
||
}
|
||
|
||
/**
|
||
* Writes templates to the file system.
|
||
*
|
||
* @async
|
||
* @method
|
||
* @returns {Promise<{}>}
|
||
*/
|
||
async write() {
|
||
return this.executeBuild();
|
||
}
|
||
|
||
/**
|
||
* Renders templates to a JSON object.
|
||
*
|
||
* @async
|
||
* @method
|
||
* @returns {Promise<{}>}
|
||
*/
|
||
async toJSON() {
|
||
return this.executeBuild("json");
|
||
}
|
||
|
||
/**
|
||
* Returns a stream of new line delimited (NDJSON) objects
|
||
*
|
||
* @async
|
||
* @method
|
||
* @returns {Promise<{ReadableStream}>}
|
||
*/
|
||
async toNDJSON() {
|
||
return this.executeBuild("ndjson");
|
||
}
|
||
|
||
/**
|
||
* tbd.
|
||
*
|
||
* @async
|
||
* @method
|
||
* @returns {Promise<{}>} ret - tbd.
|
||
*/
|
||
async executeBuild(to = "fs") {
|
||
if (this.needsInit) {
|
||
if (!this._initing) {
|
||
this._initing = this.init();
|
||
}
|
||
await this._initing;
|
||
this.needsInit = false;
|
||
}
|
||
|
||
if (!this.writer) {
|
||
this.errorHandler.fatal(
|
||
new Error(
|
||
"Eleventy didn’t run init() properly and wasn’t able to create a TemplateWriter."
|
||
),
|
||
"Problem writing Eleventy templates"
|
||
);
|
||
}
|
||
|
||
if (this.programmaticApiIncrementalFile) {
|
||
this.writer.setIncrementalFile(this.programmaticApiIncrementalFile);
|
||
}
|
||
|
||
let ret;
|
||
let hasError = false;
|
||
|
||
try {
|
||
let eventsArg = {
|
||
inputDir: this.config.inputDir,
|
||
dir: this.config.dir,
|
||
runMode: this.runMode,
|
||
outputMode: to,
|
||
incremental: this.isIncremental,
|
||
};
|
||
|
||
await this.config.events.emit("beforeBuild", eventsArg);
|
||
await this.config.events.emit("eleventy.before", eventsArg);
|
||
|
||
let promise;
|
||
if (to === "fs") {
|
||
promise = this.writer.write();
|
||
} else if (to === "json") {
|
||
promise = this.writer.getJSON("json");
|
||
} else if (to === "ndjson") {
|
||
promise = this.writer.getJSON("ndjson");
|
||
} else {
|
||
throw new Error(
|
||
`Invalid argument for \`Eleventy->executeBuild(${to})\`, expected "json", "ndjson", or "fs".`
|
||
);
|
||
}
|
||
|
||
ret = await promise;
|
||
|
||
// Passing the processed output to the eleventy.after event is new in 2.0
|
||
let [passthroughCopyResults, ...templateResults] = ret;
|
||
if (to === "fs") {
|
||
eventsArg.results = templateResults.flat().filter((entry) => !!entry);
|
||
} else {
|
||
eventsArg.results = templateResults.filter((entry) => !!entry);
|
||
}
|
||
|
||
if (to === "ndjson") {
|
||
// return a stream
|
||
// TODO this might output the ndjson rows only after all the templates have been written to the stream?
|
||
ret = this.logger.closeStream(to);
|
||
}
|
||
|
||
eventsArg.uses = this.eleventyConfig.usesGraph.map;
|
||
await this.config.events.emit("afterBuild", eventsArg);
|
||
await this.config.events.emit("eleventy.after", eventsArg);
|
||
} catch (e) {
|
||
hasError = true;
|
||
ret = {
|
||
error: e,
|
||
};
|
||
|
||
// Issue #2405
|
||
if (this.source === "script") {
|
||
this.errorHandler.error(e, "Problem writing Eleventy templates");
|
||
throw e;
|
||
} else {
|
||
this.errorHandler.fatal(e, "Problem writing Eleventy templates");
|
||
}
|
||
} finally {
|
||
this.bench.finish();
|
||
if (to === "fs") {
|
||
this.logger.message(this.logFinished(), "info", hasError ? "red" : "green", true);
|
||
}
|
||
debug("Finished writing templates.");
|
||
|
||
debug(`
|
||
Getting frustrated? Have a suggestion/feature request/feedback?
|
||
I want to hear it! Open an issue: https://github.com/11ty/eleventy/issues/new`);
|
||
}
|
||
|
||
return ret;
|
||
}
|
||
}
|
||
|
||
module.exports = Eleventy;
|
||
module.exports.EleventyServerless = require("./Serverless");
|
||
module.exports.EleventyServerlessBundlerPlugin = require("./Plugins/ServerlessBundlerPlugin");
|
||
module.exports.EleventyRenderPlugin = require("./Plugins/RenderPlugin");
|
||
module.exports.EleventyEdgePlugin = require("./Plugins/EdgePlugin");
|
||
module.exports.EleventyI18nPlugin = require("./Plugins/I18nPlugin");
|
||
module.exports.EleventyHtmlBasePlugin = require("./Plugins/HtmlBasePlugin");
|