@stencil/core 2.18.0 → 2.19.0

package/cli/index.cjs

@@ -1,5 +1,5 @@
 /*!
- Stencil CLI (CommonJS) v2.18.0 | MIT Licensed | https://stenciljs.com
+ Stencil CLI (CommonJS) v2.19.0 | MIT Licensed | https://stenciljs.com
  */
 'use strict';
 
@@ -25,29 +25,6 @@ function _interopNamespace(e) {
     return Object.freeze(n);
 }
 
-/**
- * This sets the log level hierarchy for our terminal logger, ranging from
- * most to least verbose.
- *
- * Ordering the levels like this lets us easily check whether we should log a
- * message at a given time. For instance, if the log level is set to `'warn'`,
- * then anything passed to the logger with level `'warn'` or `'error'` should
- * be logged, but we should _not_ log anything with level `'info'` or `'debug'`.
- *
- * If we have a current log level `currentLevel` and a message with level
- * `msgLevel` is passed to the logger, we can determine whether or not we should
- * log it by checking if the log level on the message is further up or at the
- * same level in the hierarchy than `currentLevel`, like so:
- *
- * ```ts
- * LOG_LEVELS.indexOf(msgLevel) >= LOG_LEVELS.indexOf(currentLevel)
- * ```
- *
- * NOTE: for the reasons described above, do not change the order of the entries
- * in this array without good reason!
- */
-const LOG_LEVELS = ['debug', 'info', 'warn', 'error'];
-
 /**
  * Convert a string from PascalCase to dash-case
  *
@@ -297,6 +274,22 @@ const pathComponents = (path, rootLength) => {
     return [root, ...rest];
 };
 
+/**
+ * Check whether a string is a member of a ReadonlyArray<string>
+ *
+ * We need a little helper for this because unfortunately `includes` is typed
+ * on `ReadonlyArray<T>` as `(el: T): boolean` so a `string` cannot be passed
+ * to `includes` on a `ReadonlyArray` 😢 thus we have a little helper function
+ * where we do the type coercion just once.
+ *
+ * see microsoft/TypeScript#31018 for some discussion of this
+ *
+ * @param readOnlyArray the array we're checking
+ * @param maybeMember a value which is possibly a member of the array
+ * @returns whether the array contains the member or not
+ */
+const readOnlyArrayHasStringMember = (readOnlyArray, maybeMember) => readOnlyArray.includes(maybeMember);
+
 /**
  * Validates that a component tag meets required naming conventions to be used for a web component
  * @param tag the tag to validate
@@ -341,6 +334,29 @@ const validateComponentTag = (tag) => {
     return undefined;
 };
 
+/**
+ * This sets the log level hierarchy for our terminal logger, ranging from
+ * most to least verbose.
+ *
+ * Ordering the levels like this lets us easily check whether we should log a
+ * message at a given time. For instance, if the log level is set to `'warn'`,
+ * then anything passed to the logger with level `'warn'` or `'error'` should
+ * be logged, but we should _not_ log anything with level `'info'` or `'debug'`.
+ *
+ * If we have a current log level `currentLevel` and a message with level
+ * `msgLevel` is passed to the logger, we can determine whether or not we should
+ * log it by checking if the log level on the message is further up or at the
+ * same level in the hierarchy than `currentLevel`, like so:
+ *
+ * ```ts
+ * LOG_LEVELS.indexOf(msgLevel) >= LOG_LEVELS.indexOf(currentLevel)
+ * ```
+ *
+ * NOTE: for the reasons described above, do not change the order of the entries
+ * in this array without good reason!
+ */
+const LOG_LEVELS = ['debug', 'info', 'warn', 'error'];
+
 /**
  * All the Boolean options supported by the Stencil CLI
  */
@@ -818,18 +834,12 @@ const parseEqualsArg = (arg) => {
  * @param maybeLogLevel the string to check
  * @returns whether this is a `LogLevel`
  */
-const isLogLevel = (maybeLogLevel) => 
-// unfortunately `includes` is typed on `ReadonlyArray<T>` as `(el: T):
-// boolean` so a `string` cannot be passed to `includes` on a
-// `ReadonlyArray` 😢 thus we `as any`
-//
-// see microsoft/TypeScript#31018 for some discussion of this
-LOG_LEVELS.includes(maybeLogLevel);
+const isLogLevel = (maybeLogLevel) => readOnlyArrayHasStringMember(LOG_LEVELS, maybeLogLevel);
 
 const dependencies = [
 	{
 		name: "@stencil/core",
-		version: "2.18.0",
+		version: "2.19.0",
 		main: "compiler/stencil.js",
 		resources: [
 			"package.json",
@@ -946,6 +956,102 @@ const dependencies = [
 	}
 ];
 
+const IS_NODE_ENV = typeof global !== 'undefined' &&
+    typeof require === 'function' &&
+    !!global.process &&
+    typeof __filename === 'string' &&
+    (!global.origin || typeof global.origin !== 'string');
+const IS_BROWSER_ENV = typeof location !== 'undefined' && typeof navigator !== 'undefined' && typeof XMLHttpRequest !== 'undefined';
+
+/**
+ * Creates an instance of a logger
+ * @returns the new logger instance
+ */
+const createLogger = () => {
+    let useColors = IS_BROWSER_ENV;
+    let level = 'info';
+    return {
+        enableColors: (uc) => (useColors = uc),
+        getLevel: () => level,
+        setLevel: (l) => (level = l),
+        emoji: (e) => e,
+        info: console.log.bind(console),
+        warn: console.warn.bind(console),
+        error: console.error.bind(console),
+        debug: console.debug.bind(console),
+        red: (msg) => msg,
+        green: (msg) => msg,
+        yellow: (msg) => msg,
+        blue: (msg) => msg,
+        magenta: (msg) => msg,
+        cyan: (msg) => msg,
+        gray: (msg) => msg,
+        bold: (msg) => msg,
+        dim: (msg) => msg,
+        bgRed: (msg) => msg,
+        createTimeSpan: (_startMsg, _debug = false) => ({
+            duration: () => 0,
+            finish: () => 0,
+        }),
+        printDiagnostics(diagnostics) {
+            diagnostics.forEach((diagnostic) => logDiagnostic(diagnostic, useColors));
+        },
+    };
+};
+const logDiagnostic = (diagnostic, useColors) => {
+    let color = BLUE;
+    let prefix = 'Build';
+    let msg = '';
+    if (diagnostic.level === 'error') {
+        color = RED;
+        prefix = 'Error';
+    }
+    else if (diagnostic.level === 'warn') {
+        color = YELLOW;
+        prefix = 'Warning';
+    }
+    if (diagnostic.header) {
+        prefix = diagnostic.header;
+    }
+    const filePath = diagnostic.relFilePath || diagnostic.absFilePath;
+    if (filePath) {
+        msg += filePath;
+        if (typeof diagnostic.lineNumber === 'number' && diagnostic.lineNumber > 0) {
+            msg += ', line ' + diagnostic.lineNumber;
+            if (typeof diagnostic.columnNumber === 'number' && diagnostic.columnNumber > 0) {
+                msg += ', column ' + diagnostic.columnNumber;
+            }
+        }
+        msg += '\n';
+    }
+    msg += diagnostic.messageText;
+    if (diagnostic.lines && diagnostic.lines.length > 0) {
+        diagnostic.lines.forEach((l) => {
+            msg += '\n' + l.lineNumber + ':  ' + l.text;
+        });
+        msg += '\n';
+    }
+    if (useColors) {
+        const styledPrefix = [
+            '%c' + prefix,
+            `background: ${color}; color: white; padding: 2px 3px; border-radius: 2px; font-size: 0.8em;`,
+        ];
+        console.log(...styledPrefix, msg);
+    }
+    else if (diagnostic.level === 'error') {
+        console.error(msg);
+    }
+    else if (diagnostic.level === 'warn') {
+        console.warn(msg);
+    }
+    else {
+        console.log(msg);
+    }
+};
+const YELLOW = `#f39c12`;
+const RED = `#c0392b`;
+const BLUE = `#3498db`;
+
 /**
  * Attempt to find a Stencil configuration file on the file system
  * @param opts the options needed to find the configuration file
@@ -954,11 +1060,7 @@ const dependencies = [
 const findConfig = async (opts) => {
     const sys = opts.sys;
     const cwd = sys.getCurrentDirectory();
-    const results = {
-        configPath: null,
-        rootDir: normalizePath(cwd),
-        diagnostics: [],
-    };
+    const rootDir = normalizePath(cwd);
     let configPath = opts.configPath;
     if (isString(configPath)) {
         if (!sys.platformPath.isAbsolute(configPath)) {
@@ -973,8 +1075,13 @@ const findConfig = async (opts) => {
     }
     else {
         // nothing was passed in, use the current working directory
-        configPath = results.rootDir;
+        configPath = rootDir;
     }
+    const results = {
+        configPath,
+        rootDir: normalizePath(cwd),
+        diagnostics: [],
+    };
     const stat = await sys.stat(configPath);
     if (stat.error) {
         const diagnostic = buildError(results.diagnostics);
@@ -1007,12 +1114,33 @@ const loadCoreCompiler = async (sys) => {
     return globalThis.stencil;
 };
 
+/**
+ * Log the name of this package (`@stencil/core`) to an output stream
+ *
+ * The output stream is determined by the {@link Logger} instance that is provided as an argument to this function
+ *
+ * The name of the package may not be logged, by design, for certain `task` types and logging levels
+ *
+ * @param logger the logging entity to use to output the name of the package
+ * @param task the current task
+ */
 const startupLog = (logger, task) => {
     if (task === 'info' || task === 'serve' || task === 'version') {
         return;
     }
     logger.info(logger.cyan(`@stencil/core`));
 };
+/**
+ * Log this package's version to an output stream
+ *
+ * The output stream is determined by the {@link Logger} instance that is provided as an argument to this function
+ *
+ * The package version may not be logged, by design, for certain `task` types and logging levels
+ *
+ * @param logger the logging entity to use for output
+ * @param task the current task
+ * @param coreCompiler the compiler instance to derive version information from
+ */
 const startupLogVersion = (logger, task, coreCompiler) => {
     if (task === 'info' || task === 'serve' || task === 'version') {
         return;
@@ -1028,11 +1156,25 @@ const startupLogVersion = (logger, task, coreCompiler) => {
     startupMsg += logger.emoji(' ' + coreCompiler.vermoji);
     logger.info(startupMsg);
 };
+/**
+ * Log details from a {@link CompilerSystem} used by Stencil to an output stream
+ *
+ * The output stream is determined by the {@link Logger} instance that is provided as an argument to this function
+ *
+ * @param sys the `CompilerSystem` to report details on
+ * @param logger the logging entity to use for output
+ * @param flags user set flags for the current invocation of Stencil
+ * @param coreCompiler the compiler instance being used for this invocation of Stencil
+ */
 const loadedCompilerLog = (sys, logger, flags, coreCompiler) => {
     const sysDetails = sys.details;
     const runtimeInfo = `${sys.name} ${sys.version}`;
-    const platformInfo = `${sysDetails.platform}, ${sysDetails.cpuModel}`;
-    const statsInfo = `cpus: ${sys.hardwareConcurrency}, freemem: ${Math.round(sysDetails.freemem() / 1000000)}MB, totalmem: ${Math.round(sysDetails.totalmem / 1000000)}MB`;
+    const platformInfo = sysDetails
+        ? `${sysDetails.platform}, ${sysDetails.cpuModel}`
+        : `Unknown Platform, Unknown CPU Model`;
+    const statsInfo = sysDetails
+        ? `cpus: ${sys.hardwareConcurrency}, freemem: ${Math.round(sysDetails.freemem() / 1000000)}MB, totalmem: ${Math.round(sysDetails.totalmem / 1000000)}MB`
+        : 'Unknown CPU Core Count, Unknown Memory';
     if (logger.getLevel() === 'debug') {
         logger.debug(runtimeInfo);
         logger.debug(platformInfo);
@@ -1046,6 +1188,14 @@ const loadedCompilerLog = (sys, logger, flags, coreCompiler) => {
         logger.info(statsInfo);
     }
 };
+/**
+ * Log various warnings to an output stream
+ *
+ * The output stream is determined by the {@link Logger} instance attached to the `config` argument to this function
+ *
+ * @param coreCompiler the compiler instance being used for this invocation of Stencil
+ * @param config a validated configuration object to be used for this run of Stencil
+ */
 const startupCompilerLog = (coreCompiler, config) => {
     if (config.suppressLogs === true) {
         return;
@@ -1067,6 +1217,21 @@ const startupCompilerLog = (coreCompiler, config) => {
     }
 };
 
+const startCheckVersion = async (config, currentVersion) => {
+    if (config.devMode && !config.flags.ci && !currentVersion.includes('-dev.') && isFunction(config.sys.checkVersion)) {
+        return config.sys.checkVersion(config.logger, currentVersion);
+    }
+    return null;
+};
+const printCheckVersionResults = async (versionChecker) => {
+    if (versionChecker) {
+        const checkVersionResults = await versionChecker;
+        if (isFunction(checkVersionResults)) {
+            checkVersionResults();
+        }
+    }
+};
+
 const taskPrerender = async (coreCompiler, config) => {
     startupCompilerLog(coreCompiler, config);
     const hydrateAppFilePath = config.flags.unknownArgs[0];
@@ -1098,21 +1263,6 @@ const runPrerenderTask = async (coreCompiler, config, hydrateAppFilePath, compon
     return diagnostics;
 };
 
-const startCheckVersion = async (config, currentVersion) => {
-    if (config.devMode && !config.flags.ci && !currentVersion.includes('-dev.') && isFunction(config.sys.checkVersion)) {
-        return config.sys.checkVersion(config.logger, currentVersion);
-    }
-    return null;
-};
-const printCheckVersionResults = async (versionChecker) => {
-    if (versionChecker) {
-        const checkVersionResults = await versionChecker;
-        if (isFunction(checkVersionResults)) {
-            checkVersionResults();
-        }
-    }
-};
-
 const taskWatch = async (coreCompiler, config) => {
     let devServer = null;
     let exitCode = 0;
@@ -1159,6 +1309,15 @@ const taskWatch = async (coreCompiler, config) => {
     }
 };
 
+const isOutputTargetHydrate = (o) => o.type === DIST_HYDRATE_SCRIPT;
+const isOutputTargetDocs = (o) => o.type === DOCS_README || o.type === DOCS_JSON || o.type === DOCS_CUSTOM || o.type === DOCS_VSCODE;
+const DIST_HYDRATE_SCRIPT = 'dist-hydrate-script';
+const DOCS_CUSTOM = 'docs-custom';
+const DOCS_JSON = 'docs-json';
+const DOCS_README = 'docs-readme';
+const DOCS_VSCODE = 'docs-vscode';
+const WWW = 'www';
+
 const tryFn = async (fn, ...args) => {
     try {
         return await fn(...args);
@@ -1172,7 +1331,7 @@ const isInteractive = (sys, flags, object) => {
     const terminalInfo = object ||
         Object.freeze({
             tty: sys.isTTY() ? true : false,
-            ci: ['CI', 'BUILD_ID', 'BUILD_NUMBER', 'BITBUCKET_COMMIT', 'CODEBUILD_BUILD_ARN'].filter((v) => !!sys.getEnvironmentVar(v)).length > 0 || !!flags.ci,
+            ci: ['CI', 'BUILD_ID', 'BUILD_NUMBER', 'BITBUCKET_COMMIT', 'CODEBUILD_BUILD_ARN'].filter((v) => { var _a; return !!((_a = sys.getEnvironmentVar) === null || _a === void 0 ? void 0 : _a.call(sys, v)); }).length > 0 || !!flags.ci,
         });
     return terminalInfo.tty && !terminalInfo.ci;
 };
@@ -1201,7 +1360,7 @@ async function readJson(sys, path) {
  * @returns true if --debug has been passed, otherwise false
  */
 function hasDebug(flags) {
-    return flags.debug;
+    return !!flags.debug;
 }
 /**
  * Does the command have the verbose and debug flags?
@@ -1209,18 +1368,7 @@ function hasDebug(flags) {
  * @returns true if both --debug and --verbose have been passed, otherwise false
  */
 function hasVerbose(flags) {
-    return flags.verbose && hasDebug(flags);
-}
-
-/**
- * Used to determine if tracking should occur.
- * @param config The config passed into the Stencil command
- * @param sys The system where the command is invoked
- * @param ci whether or not the process is running in a Continuous Integration (CI) environment
- * @returns true if telemetry should be sent, false otherwise
- */
-async function shouldTrack(config, sys, ci) {
-    return !ci && isInteractive(sys, config.flags) && (await checkTelemetry(sys));
+    return !!flags.verbose && hasDebug(flags);
 }
 
 const isTest$1 = () => process.env.JEST_WORKER_ID !== undefined;
@@ -1241,7 +1389,7 @@ async function readConfig(sys) {
         };
         await writeConfig(sys, config);
     }
-    else if (!UUID_REGEX.test(config['tokens.telemetry'])) {
+    else if (!config['tokens.telemetry'] || !UUID_REGEX.test(config['tokens.telemetry'])) {
         const newUuid = uuidv4();
         await writeConfig(sys, { ...config, 'tokens.telemetry': newUuid });
         config['tokens.telemetry'] = newUuid;
@@ -1277,14 +1425,16 @@ async function updateConfig(sys, newOptions) {
     return await writeConfig(sys, Object.assign(config, newOptions));
 }
 
-const isOutputTargetHydrate = (o) => o.type === DIST_HYDRATE_SCRIPT;
-const isOutputTargetDocs = (o) => o.type === DOCS_README || o.type === DOCS_JSON || o.type === DOCS_CUSTOM || o.type === DOCS_VSCODE;
-const DIST_HYDRATE_SCRIPT = 'dist-hydrate-script';
-const DOCS_CUSTOM = 'docs-custom';
-const DOCS_JSON = 'docs-json';
-const DOCS_README = 'docs-readme';
-const DOCS_VSCODE = 'docs-vscode';
-const WWW = 'www';
+/**
+ * Used to determine if tracking should occur.
+ * @param config The config passed into the Stencil command
+ * @param sys The system where the command is invoked
+ * @param ci whether or not the process is running in a Continuous Integration (CI) environment
+ * @returns true if telemetry should be sent, false otherwise
+ */
+async function shouldTrack(config, sys, ci) {
+    return !ci && isInteractive(sys, config.flags) && (await checkTelemetry(sys));
+}
 
 /**
  * Used to within taskBuild to provide the component_count property.
@@ -1295,11 +1445,11 @@ const WWW = 'www';
  * @param result The results of a compiler build.
  */
 async function telemetryBuildFinishedAction(sys, config, coreCompiler, result) {
-    const tracking = await shouldTrack(config, sys, config.flags.ci);
+    const tracking = await shouldTrack(config, sys, !!config.flags.ci);
     if (!tracking) {
         return;
     }
-    const component_count = Object.keys(result.componentGraph).length;
+    const component_count = result.componentGraph ? Object.keys(result.componentGraph).length : undefined;
     const data = await prepareData(coreCompiler, config, sys, result.duration, component_count);
     await sendMetric(sys, config, 'stencil_cli_command', data);
     config.logger.debug(`${config.logger.blue('Telemetry')}: ${config.logger.gray(JSON.stringify(data))}`);
@@ -1378,38 +1528,41 @@ function getActiveTargets(config) {
  * @returns a Promise wrapping data for the telemetry endpoint
  */
 const prepareData = async (coreCompiler, config, sys, duration_ms, component_count = undefined) => {
+    var _a, _b, _c;
     const { typescript, rollup } = coreCompiler.versions || { typescript: 'unknown', rollup: 'unknown' };
     const { packages, packagesNoVersions } = await getInstalledPackages(sys, config);
     const targets = getActiveTargets(config);
     const yarn = isUsingYarn(sys);
     const stencil = coreCompiler.version || 'unknown';
     const system = `${sys.name} ${sys.version}`;
-    const os_name = sys.details.platform;
-    const os_version = sys.details.release;
-    const cpu_model = sys.details.cpuModel;
+    const os_name = (_a = sys.details) === null || _a === void 0 ? void 0 : _a.platform;
+    const os_version = (_b = sys.details) === null || _b === void 0 ? void 0 : _b.release;
+    const cpu_model = (_c = sys.details) === null || _c === void 0 ? void 0 : _c.cpuModel;
     const build = coreCompiler.buildId || 'unknown';
     const has_app_pwa_config = hasAppTarget(config);
     const anonymizedConfig = anonymizeConfigForTelemetry(config);
+    const is_browser_env = IS_BROWSER_ENV;
     return {
-        yarn,
-        duration_ms,
+        arguments: config.flags.args,
+        build,
         component_count,
-        targets,
+        config: anonymizedConfig,
+        cpu_model,
+        duration_ms,
+        has_app_pwa_config,
+        is_browser_env,
+        os_name,
+        os_version,
         packages,
         packages_no_versions: packagesNoVersions,
-        arguments: config.flags.args,
-        task: config.flags.task,
+        rollup,
         stencil,
         system,
         system_major: getMajorVersion(system),
-        os_name,
-        os_version,
-        cpu_model,
-        build,
+        targets,
+        task: config.flags.task,
         typescript,
-        rollup,
-        has_app_pwa_config,
-        config: anonymizedConfig,
+        yarn,
     };
 };
 // props in output targets for which we retain their original values when
@@ -1716,13 +1869,6 @@ const taskDocs = async (coreCompiler, config) => {
     await compiler.destroy();
 };
 
-const IS_NODE_ENV = typeof global !== 'undefined' &&
-    typeof require === 'function' &&
-    !!global.process &&
-    typeof __filename === 'string' &&
-    (!global.origin || typeof global.origin !== 'string');
-const IS_BROWSER_ENV = typeof location !== 'undefined' && typeof navigator !== 'undefined' && typeof XMLHttpRequest !== 'undefined';
-
 /**
  * Task to generate component boilerplate and write it to disk. This task can
  * cause the program to exit with an error under various circumstances, such as
@@ -1983,7 +2129,7 @@ const taskTelemetry = async (flags, sys, logger) => {
     const prompt = logger.dim(sys.details.platform === 'windows' ? '>' : '$');
     const isEnabling = flags.args.includes('on');
     const isDisabling = flags.args.includes('off');
-    const INFORMATION = `Opt in or our of telemetry. Information about the data we collect is available on our website: ${logger.bold('https://stenciljs.com/telemetry')}`;
+    const INFORMATION = `Opt in or out of telemetry. Information about the data we collect is available on our website: ${logger.bold('https://stenciljs.com/telemetry')}`;
     const THANK_YOU = `Thank you for helping to make Stencil better! 💖`;
     const ENABLED_MESSAGE = `${logger.green('Enabled')}. ${THANK_YOU}\n\n`;
     const DISABLED_MESSAGE = `${logger.red('Disabled')}\n\n`;
@@ -2114,32 +2260,32 @@ const taskTest = async (config) => {
         config.logger.error(`"test" command is currently only implemented for a NodeJS environment`);
         return config.sys.exit(1);
     }
-    try {
-        config.buildDocs = false;
-        const testingRunOpts = {
-            e2e: !!config.flags.e2e,
-            screenshot: !!config.flags.screenshot,
-            spec: !!config.flags.spec,
-            updateScreenshot: !!config.flags.updateScreenshot,
-        };
-        // always ensure we have jest modules installed
-        const ensureModuleIds = ['@types/jest', 'jest', 'jest-cli'];
-        if (testingRunOpts.e2e) {
-            // if it's an e2e test, also make sure we're got
-            // puppeteer modules installed and if browserExecutablePath is provided don't download Chromium use only puppeteer-core instead
-            const puppeteer = config.testing.browserExecutablePath ? 'puppeteer-core' : 'puppeteer';
-            ensureModuleIds.push(puppeteer);
-            if (testingRunOpts.screenshot) {
-                // ensure we've got pixelmatch for screenshots
-                config.logger.warn(config.logger.yellow(`EXPERIMENTAL: screenshot visual diff testing is currently under heavy development and has not reached a stable status. However, any assistance testing would be appreciated.`));
-            }
-        }
-        // ensure we've got the required modules installed
-        const diagnostics = await config.sys.lazyRequire.ensure(config.rootDir, ensureModuleIds);
-        if (diagnostics.length > 0) {
-            config.logger.printDiagnostics(diagnostics);
-            return config.sys.exit(1);
+    config.buildDocs = false;
+    const testingRunOpts = {
+        e2e: !!config.flags.e2e,
+        screenshot: !!config.flags.screenshot,
+        spec: !!config.flags.spec,
+        updateScreenshot: !!config.flags.updateScreenshot,
+    };
+    // always ensure we have jest modules installed
+    const ensureModuleIds = ['@types/jest', 'jest', 'jest-cli'];
+    if (testingRunOpts.e2e) {
+        // if it's an e2e test, also make sure we're got
+        // puppeteer modules installed and if browserExecutablePath is provided don't download Chromium use only puppeteer-core instead
+        const puppeteer = config.testing.browserExecutablePath ? 'puppeteer-core' : 'puppeteer';
+        ensureModuleIds.push(puppeteer);
+        if (testingRunOpts.screenshot) {
+            // ensure we've got pixelmatch for screenshots
+            config.logger.warn(config.logger.yellow(`EXPERIMENTAL: screenshot visual diff testing is currently under heavy development and has not reached a stable status. However, any assistance testing would be appreciated.`));
         }
+    }
+    // ensure we've got the required modules installed
+    const diagnostics = await config.sys.lazyRequire.ensure(config.rootDir, ensureModuleIds);
+    if (diagnostics.length > 0) {
+        config.logger.printDiagnostics(diagnostics);
+        return config.sys.exit(1);
+    }
+    try {
         // let's test!
         const { createTesting } = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('../testing/index.js')); });
         const testing = await createTesting(config);
@@ -2155,95 +2301,6 @@ const taskTest = async (config) => {
     }
 };
 
-/**
- * Creates an instance of a logger
- * @returns the new logger instance
- */
-const createLogger = () => {
-    let useColors = IS_BROWSER_ENV;
-    let level = 'info';
-    return {
-        enableColors: (uc) => (useColors = uc),
-        getLevel: () => level,
-        setLevel: (l) => (level = l),
-        emoji: (e) => e,
-        info: console.log.bind(console),
-        warn: console.warn.bind(console),
-        error: console.error.bind(console),
-        debug: console.debug.bind(console),
-        red: (msg) => msg,
-        green: (msg) => msg,
-        yellow: (msg) => msg,
-        blue: (msg) => msg,
-        magenta: (msg) => msg,
-        cyan: (msg) => msg,
-        gray: (msg) => msg,
-        bold: (msg) => msg,
-        dim: (msg) => msg,
-        bgRed: (msg) => msg,
-        createTimeSpan: (_startMsg, _debug = false) => ({
-            duration: () => 0,
-            finish: () => 0,
-        }),
-        printDiagnostics(diagnostics) {
-            diagnostics.forEach((diagnostic) => logDiagnostic(diagnostic, useColors));
-        },
-    };
-};
-const logDiagnostic = (diagnostic, useColors) => {
-    let color = BLUE;
-    let prefix = 'Build';
-    let msg = '';
-    if (diagnostic.level === 'error') {
-        color = RED;
-        prefix = 'Error';
-    }
-    else if (diagnostic.level === 'warn') {
-        color = YELLOW;
-        prefix = 'Warning';
-    }
-    if (diagnostic.header) {
-        prefix = diagnostic.header;
-    }
-    const filePath = diagnostic.relFilePath || diagnostic.absFilePath;
-    if (filePath) {
-        msg += filePath;
-        if (typeof diagnostic.lineNumber === 'number' && diagnostic.lineNumber > 0) {
-            msg += ', line ' + diagnostic.lineNumber;
-            if (typeof diagnostic.columnNumber === 'number' && diagnostic.columnNumber > 0) {
-                msg += ', column ' + diagnostic.columnNumber;
-            }
-        }
-        msg += '\n';
-    }
-    msg += diagnostic.messageText;
-    if (diagnostic.lines && diagnostic.lines.length > 0) {
-        diagnostic.lines.forEach((l) => {
-            msg += '\n' + l.lineNumber + ':  ' + l.text;
-        });
-        msg += '\n';
-    }
-    if (useColors) {
-        const styledPrefix = [
-            '%c' + prefix,
-            `background: ${color}; color: white; padding: 2px 3px; border-radius: 2px; font-size: 0.8em;`,
-        ];
-        console.log(...styledPrefix, msg);
-    }
-    else if (diagnostic.level === 'error') {
-        console.error(msg);
-    }
-    else if (diagnostic.level === 'warn') {
-        console.warn(msg);
-    }
-    else {
-        console.log(msg);
-    }
-};
-const YELLOW = `#f39c12`;
-const RED = `#c0392b`;
-const BLUE = `#3498db`;
-
 const run = async (init) => {
     const { args, logger, sys } = init;
     try {
@@ -2258,7 +2315,7 @@ const run = async (init) => {
         if (isFunction(sys.applyGlobalPatch)) {
             sys.applyGlobalPatch(sys.getCurrentDirectory());
         }
-        if (task === 'help' || flags.help) {
+        if (!task || task === 'help' || flags.help) {
             await taskHelp(createConfigFlags({ task: 'help', args }), logger, sys);
             return;
         }