diff options
Diffstat (limited to 'node_modules/@11ty/eleventy/src/Errors')
7 files changed, 270 insertions, 0 deletions
diff --git a/node_modules/@11ty/eleventy/src/Errors/DuplicatePermalinkOutputError.js b/node_modules/@11ty/eleventy/src/Errors/DuplicatePermalinkOutputError.js new file mode 100644 index 0000000..444195c --- /dev/null +++ b/node_modules/@11ty/eleventy/src/Errors/DuplicatePermalinkOutputError.js @@ -0,0 +1,9 @@ +import EleventyBaseError from "./EleventyBaseError.js"; + +class DuplicatePermalinkOutputError extends EleventyBaseError { + get removeDuplicateErrorStringFromOutput() { + return true; + } +} + +export default DuplicatePermalinkOutputError; diff --git a/node_modules/@11ty/eleventy/src/Errors/EleventyBaseError.js b/node_modules/@11ty/eleventy/src/Errors/EleventyBaseError.js new file mode 100644 index 0000000..6e76c5f --- /dev/null +++ b/node_modules/@11ty/eleventy/src/Errors/EleventyBaseError.js @@ -0,0 +1,24 @@ +/** + * This class serves as basis for all Eleventy-specific errors. + * @ignore + */ +class EleventyBaseError extends Error { + /** + * @param {string} message - The error message to display. + * @param {unknown} [originalError] - The original error caught. + */ + constructor(message, originalError) { + super(message); + + this.name = this.constructor.name; + + if (Error.captureStackTrace) { + Error.captureStackTrace(this, this.constructor); + } + + if (originalError) { + this.originalError = originalError; + } + } +} +export default EleventyBaseError; diff --git a/node_modules/@11ty/eleventy/src/Errors/EleventyErrorHandler.js b/node_modules/@11ty/eleventy/src/Errors/EleventyErrorHandler.js new file mode 100644 index 0000000..879e65c --- /dev/null +++ b/node_modules/@11ty/eleventy/src/Errors/EleventyErrorHandler.js @@ -0,0 +1,152 @@ +import util from "node:util"; +import debugUtil from "debug"; + +import ConsoleLogger from "../Util/ConsoleLogger.js"; +import EleventyErrorUtil from "./EleventyErrorUtil.js"; + +const debug = debugUtil("Eleventy:EleventyErrorHandler"); + +class EleventyErrorHandler { + constructor() { + this._isVerbose = true; + } + + get isVerbose() { + return this._isVerbose; + } + + set isVerbose(verbose) { + this._isVerbose = !!verbose; + this.logger.isVerbose = !!verbose; + } + + get logger() { + if (!this._logger) { + this._logger = new ConsoleLogger(); + this._logger.isVerbose = this.isVerbose; + } + + return this._logger; + } + + set logger(logger) { + this._logger = logger; + } + + warn(e, msg) { + if (msg) { + this.initialMessage(msg, "warn", "yellow"); + } + this.log(e, "warn"); + } + + fatal(e, msg) { + this.error(e, msg); + process.exitCode = 1; + } + + once(type, e, msg) { + if (e.__errorAlreadyLogged) { + return; + } + + this[type || "error"](e, msg); + + Object.defineProperty(e, "__errorAlreadyLogged", { + value: true, + }); + } + + error(e, msg) { + if (msg) { + this.initialMessage(msg, "error", "red", true); + } + this.log(e, "error", undefined, true); + } + + static getTotalErrorCount(e) { + let totalErrorCount = 0; + let errorCountRef = e; + while (errorCountRef) { + totalErrorCount++; + errorCountRef = errorCountRef.originalError; + } + return totalErrorCount; + } + + //https://nodejs.org/api/process.html + log(e, type = "log", chalkColor = "", forceToConsole = false) { + if (process.env.DEBUG) { + debug("Full error object: %o", util.inspect(e, { showHidden: false, depth: null })); + } + + let showStack = true; + if (e.skipOriginalStack) { + // Don’t show the full error stack trace + showStack = false; + } + + let totalErrorCount = EleventyErrorHandler.getTotalErrorCount(e); + let ref = e; + let index = 1; + while (ref) { + let nextRef = ref.originalError; + + // Unwrap cause from error and assign it to what Eleventy expects + if (nextRef?.cause) { + nextRef.originalError = nextRef.cause?.originalError ?? nextRef?.cause; + } + + if (!nextRef && EleventyErrorUtil.hasEmbeddedError(ref.message)) { + nextRef = EleventyErrorUtil.deconvertErrorToObject(ref); + } + + if (nextRef?.skipOriginalStack) { + showStack = false; + } + + this.logger.message( + `${totalErrorCount > 1 ? `${index}. ` : ""}${( + EleventyErrorUtil.cleanMessage(ref.message) || "(No error message provided)" + ).trim()}${ref.name !== "Error" ? ` (via ${ref.name})` : ""}`, + type, + chalkColor, + forceToConsole, + ); + + if (process.env.DEBUG) { + debug(`(${type} stack): ${ref.stack}`); + } else if (!nextRef) { + // last error in the loop + + // remove duplicate error messages if the stack contains the original message output above + let stackStr = ref.stack || ""; + if (e.removeDuplicateErrorStringFromOutput) { + stackStr = stackStr.replace( + `${ref.name}: ${ref.message}`, + "(Repeated output has been truncated…)", + ); + } + + if (showStack) { + this.logger.message( + "\nOriginal error stack trace: " + stackStr, + type, + chalkColor, + forceToConsole, + ); + } + } + ref = nextRef; + index++; + } + } + + initialMessage(message, type = "log", chalkColor = "blue", forceToConsole = false) { + if (message) { + this.logger.message(message + ":", type, chalkColor, forceToConsole); + } + } +} + +export { EleventyErrorHandler }; diff --git a/node_modules/@11ty/eleventy/src/Errors/EleventyErrorUtil.js b/node_modules/@11ty/eleventy/src/Errors/EleventyErrorUtil.js new file mode 100644 index 0000000..6b374d0 --- /dev/null +++ b/node_modules/@11ty/eleventy/src/Errors/EleventyErrorUtil.js @@ -0,0 +1,70 @@ +import TemplateContentPrematureUseError from "./TemplateContentPrematureUseError.js"; + +/* Hack to workaround the variety of error handling schemes in template languages */ +class EleventyErrorUtil { + static get prefix() { + return ">>>>>11ty>>>>>"; + } + static get suffix() { + return "<<<<<11ty<<<<<"; + } + + static hasEmbeddedError(msg) { + if (!msg) { + return false; + } + + return msg.includes(EleventyErrorUtil.prefix) && msg.includes(EleventyErrorUtil.suffix); + } + + static cleanMessage(msg) { + if (!msg) { + return ""; + } + + if (!EleventyErrorUtil.hasEmbeddedError(msg)) { + return "" + msg; + } + + return msg.slice(0, Math.max(0, msg.indexOf(EleventyErrorUtil.prefix))); + } + + static deconvertErrorToObject(error) { + if (!error || !error.message) { + throw new Error(`Could not convert error object from: ${error}`); + } + if (!EleventyErrorUtil.hasEmbeddedError(error.message)) { + return error; + } + + let msg = error.message; + let objectString = msg.substring( + msg.indexOf(EleventyErrorUtil.prefix) + EleventyErrorUtil.prefix.length, + msg.lastIndexOf(EleventyErrorUtil.suffix), + ); + let obj = JSON.parse(objectString); + obj.name = error.name; + return obj; + } + + // pass an error through a random template engine’s error handling unscathed + static convertErrorToString(error) { + return ( + EleventyErrorUtil.prefix + + JSON.stringify({ message: error.message, stack: error.stack }) + + EleventyErrorUtil.suffix + ); + } + + static isPrematureTemplateContentError(e) { + // TODO the rest of the template engines + return ( + e instanceof TemplateContentPrematureUseError || + e?.cause instanceof TemplateContentPrematureUseError || // Custom (per Node-convention) + ["RenderError", "UndefinedVariableError"].includes(e?.originalError?.name) && e?.originalError?.originalError instanceof TemplateContentPrematureUseError || // Liquid + e?.message?.includes("TemplateContentPrematureUseError") // Nunjucks + ); + } +} + +export default EleventyErrorUtil; diff --git a/node_modules/@11ty/eleventy/src/Errors/TemplateContentPrematureUseError.js b/node_modules/@11ty/eleventy/src/Errors/TemplateContentPrematureUseError.js new file mode 100644 index 0000000..5266cd2 --- /dev/null +++ b/node_modules/@11ty/eleventy/src/Errors/TemplateContentPrematureUseError.js @@ -0,0 +1,5 @@ +import EleventyBaseError from "./EleventyBaseError.js"; + +class TemplateContentPrematureUseError extends EleventyBaseError {} + +export default TemplateContentPrematureUseError; diff --git a/node_modules/@11ty/eleventy/src/Errors/TemplateContentUnrenderedTemplateError.js b/node_modules/@11ty/eleventy/src/Errors/TemplateContentUnrenderedTemplateError.js new file mode 100644 index 0000000..ee270d5 --- /dev/null +++ b/node_modules/@11ty/eleventy/src/Errors/TemplateContentUnrenderedTemplateError.js @@ -0,0 +1,5 @@ +import EleventyBaseError from "./EleventyBaseError.js"; + +class TemplateContentUnrenderedTemplateError extends EleventyBaseError {} + +export default TemplateContentUnrenderedTemplateError; diff --git a/node_modules/@11ty/eleventy/src/Errors/UsingCircularTemplateContentReferenceError.js b/node_modules/@11ty/eleventy/src/Errors/UsingCircularTemplateContentReferenceError.js new file mode 100644 index 0000000..5608feb --- /dev/null +++ b/node_modules/@11ty/eleventy/src/Errors/UsingCircularTemplateContentReferenceError.js @@ -0,0 +1,5 @@ +import EleventyBaseError from "./EleventyBaseError.js"; + +class UsingCircularTemplateContentReferenceError extends EleventyBaseError {} + +export default UsingCircularTemplateContentReferenceError; |