@stencil/core 2.19.2 → 2.19.3

package/cli/index.cjs

@@ -1,5 +1,5 @@
 /*!
- Stencil CLI (CommonJS) v2.19.2 | MIT Licensed | https://stenciljs.com
+ Stencil CLI (CommonJS) v2.19.3 | MIT Licensed | https://stenciljs.com
  */
 'use strict';
 
@@ -25,18 +25,6 @@ function _interopNamespace(e) {
     return Object.freeze(n);
 }
 
-/**
- * Convert a string from PascalCase to dash-case
- *
- * @param str the string to convert
- * @returns a converted string
- */
-const toDashCase = (str) => str
-    .replace(/([A-Z0-9])/g, (match) => ` ${match[0]}`)
-    .trim()
-    .split(' ')
-    .join('-')
-    .toLowerCase();
 /**
  * Convert a string from dash-case / kebab-case to PascalCase (or CamelCase,
  * or whatever you call it!)
@@ -49,6 +37,16 @@ const dashToPascalCase = (str) => str
     .split('-')
     .map((segment) => segment.charAt(0).toUpperCase() + segment.slice(1))
     .join('');
+/**
+ * Convert a string to 'camelCase'
+ *
+ * @param str the string to convert
+ * @returns the converted string
+ */
+const toCamelCase = (str) => {
+    const pascalCase = dashToPascalCase(str);
+    return pascalCase.charAt(0).toLowerCase() + pascalCase.slice(1);
+};
 const isFunction = (v) => typeof v === 'function';
 const isString = (v) => typeof v === 'string';
 
@@ -360,7 +358,7 @@ const LOG_LEVELS = ['debug', 'info', 'warn', 'error'];
 /**
  * All the Boolean options supported by the Stencil CLI
  */
-const BOOLEAN_CLI_ARGS = [
+const BOOLEAN_CLI_FLAGS = [
     'build',
     'cache',
     'checkVersion',
@@ -443,7 +441,7 @@ const BOOLEAN_CLI_ARGS = [
 /**
  * All the Number options supported by the Stencil CLI
  */
-const NUMBER_CLI_ARGS = [
+const NUMBER_CLI_FLAGS = [
     'port',
     // JEST CLI ARGS
     'maxConcurrency',
@@ -452,7 +450,7 @@ const NUMBER_CLI_ARGS = [
 /**
  * All the String options supported by the Stencil CLI
  */
-const STRING_CLI_ARGS = [
+const STRING_CLI_FLAGS = [
     'address',
     'config',
     'docsApi',
@@ -491,7 +489,8 @@ const STRING_CLI_ARGS = [
     'testURL',
     'timers',
     'transform',
-    // ARRAY ARGS
+];
+const STRING_ARRAY_CLI_FLAGS = [
     'collectCoverageOnlyFrom',
     'coveragePathIgnorePatterns',
     'coverageReporters',
@@ -520,7 +519,7 @@ const STRING_CLI_ARGS = [
  * `maxWorkers` is an argument which is used both by Stencil _and_ by Jest,
  * which means that we need to support parsing both string and number values.
  */
-const STRING_NUMBER_CLI_ARGS = ['maxWorkers'];
+const STRING_NUMBER_CLI_FLAGS = ['maxWorkers'];
 /**
  * All the LogLevel-type options supported by the Stencil CLI
  *
@@ -528,16 +527,21 @@ const STRING_NUMBER_CLI_ARGS = ['maxWorkers'];
  * but this approach lets us make sure that we're handling all
  * our arguments in a type-safe way.
  */
-const LOG_LEVEL_CLI_ARGS = ['logLevel'];
+const LOG_LEVEL_CLI_FLAGS = ['logLevel'];
 /**
  * For a small subset of CLI options we support a short alias e.g. `'h'` for `'help'`
  */
-const CLI_ARG_ALIASES = {
-    config: 'c',
-    help: 'h',
-    port: 'p',
-    version: 'v',
+const CLI_FLAG_ALIASES = {
+    c: 'config',
+    h: 'help',
+    p: 'port',
+    v: 'version',
 };
+/**
+ * A regular expression which can be used to match a CLI flag for one of our
+ * short aliases.
+ */
+const CLI_FLAG_REGEX = new RegExp(`^-[chpv]{1}$`);
 /**
  * Helper function for initializing a `ConfigFlags` object. Provide any overrides
  * for default values and off you go!
@@ -570,8 +574,14 @@ const parseFlags = (args, _sys) => {
     flags.args = Array.isArray(args) ? args.slice() : [];
     if (flags.args.length > 0 && flags.args[0] && !flags.args[0].startsWith('-')) {
         flags.task = flags.args[0];
+        // if the first argument was a "task" (like `build`, `test`, etc) then
+        // we go on to parse the _rest_ of the CLI args
+        parseArgs(flags, args.slice(1));
+    }
+    else {
+        // we didn't find a leading flag, so we should just parse them all
+        parseArgs(flags, flags.args);
     }
-    parseArgs(flags, flags.args);
     if (flags.task != null) {
         const i = flags.args.indexOf(flags.task);
         if (i > -1) {
@@ -588,120 +598,259 @@ const parseFlags = (args, _sys) => {
     return flags;
 };
 /**
- * Parse command line arguments that are enumerated in the `config-flags`
- * module. Handles leading dashes on arguments, aliases that are defined for a
- * small number of arguments, and parsing values for non-boolean arguments
- * (e.g. port number for the dev server).
+ * Parse the supported command line flags which are enumerated in the
+ * `config-flags` module. Handles leading dashes on arguments, aliases that are
+ * defined for a small number of arguments, and parsing values for non-boolean
+ * arguments (e.g. port number for the dev server).
+ *
+ * This parses the following grammar:
+ *
+ * CLIArguments    → ""
+ *                 | CLITerm ( " " CLITerm )* ;
+ * CLITerm         → EqualsArg
+ *                 | AliasEqualsArg
+ *                 | AliasArg
+ *                 | NegativeDashArg
+ *                 | NegativeArg
+ *                 | SimpleArg ;
+ * EqualsArg       → "--" ArgName "=" CLIValue ;
+ * AliasEqualsArg  → "-" AliasName "=" CLIValue ;
+ * AliasArg        → "-" AliasName ( " " CLIValue )? ;
+ * NegativeDashArg → "--no-" ArgName ;
+ * NegativeArg     → "--no" ArgName ;
+ * SimpleArg       → "--" ArgName ( " " CLIValue )? ;
+ * ArgName         → /^[a-zA-Z-]+$/ ;
+ * AliasName       → /^[a-z]{1}$/ ;
+ * CLIValue        → '"' /^[a-zA-Z0-9]+$/ '"'
+ *                 | /^[a-zA-Z0-9]+$/ ;
+ *
+ * There are additional constraints (not shown in the grammar for brevity's sake)
+ * on the type of `CLIValue` which will be associated with a particular argument.
+ * We enforce this by declaring lists of boolean, string, etc arguments and
+ * checking the types of values before setting them.
+ *
+ * We don't need to turn the list of CLI arg tokens into any kind of
+ * intermediate representation since we aren't concerned with doing anything
+ * other than setting the correct values on our ConfigFlags object. So we just
+ * parse the array of string arguments using a recursive-descent approach
+ * (which is not very deep since our grammar is pretty simple) and make the
+ * modifications we need to make to the {@link ConfigFlags} object as we go.
  *
  * @param flags a ConfigFlags object to which parsed arguments will be added
  * @param args  an array of command-line arguments to parse
  */
 const parseArgs = (flags, args) => {
-    BOOLEAN_CLI_ARGS.forEach((argName) => parseBooleanArg(flags, args, argName));
-    STRING_CLI_ARGS.forEach((argName) => parseStringArg(flags, args, argName));
-    NUMBER_CLI_ARGS.forEach((argName) => parseNumberArg(flags, args, argName));
-    STRING_NUMBER_CLI_ARGS.forEach((argName) => parseStringNumberArg(flags, args, argName));
-    LOG_LEVEL_CLI_ARGS.forEach((argName) => parseLogLevelArg(flags, args, argName));
+    const argsCopy = args.concat();
+    while (argsCopy.length > 0) {
+        // there are still unprocessed args to deal with
+        parseCLITerm(flags, argsCopy);
+    }
 };
 /**
- * Parse a boolean CLI argument. For these, we support the following formats:
- *
- * - `--booleanArg`
- * - `--boolean-arg`
- * - `--noBooleanArg`
- * - `--no-boolean-arg`
- *
- * The final two variants should be parsed to a value of `false` on the config
- * object.
+ * Given an array of CLI arguments, parse it and perform a series of side
+ * effects (setting values on the provided `ConfigFlags` object).
  *
- * @param flags the config flags object, while we'll modify
- * @param args our CLI arguments
- * @param configCaseName the argument we want to look at right now
+ * @param flags a {@link ConfigFlags} object which is updated as we parse the CLI
+ * arguments
+ * @param args a list of args to work through. This function (and some functions
+ * it calls) calls `Array.prototype.shift` to get the next argument to look at,
+ * so this parameter will be modified.
  */
-const parseBooleanArg = (flags, args, configCaseName) => {
-    // we support both dash-case and PascalCase versions of the parameter
-    // argName is 'configCase' version which can be found in BOOLEAN_ARG_OPTS
-    const alias = CLI_ARG_ALIASES[configCaseName];
-    const dashCaseName = toDashCase(configCaseName);
-    if (typeof flags[configCaseName] !== 'boolean') {
-        flags[configCaseName] = null;
-    }
-    args.forEach((cmdArg) => {
-        let value;
-        if (cmdArg === `--${configCaseName}` || cmdArg === `--${dashCaseName}`) {
-            value = true;
-        }
-        else if (cmdArg === `--no-${dashCaseName}` || cmdArg === `--no${dashToPascalCase(dashCaseName)}`) {
-            value = false;
-        }
-        else if (alias && cmdArg === `-${alias}`) {
-            value = true;
-        }
-        if (value !== undefined && cmdArg !== undefined) {
-            flags[configCaseName] = value;
-            flags.knownArgs.push(cmdArg);
-        }
-    });
+const parseCLITerm = (flags, args) => {
+    // pull off the first arg from the argument array
+    const arg = args.shift();
+    // array is empty, we're done!
+    if (arg === undefined)
+        return;
+    // EqualsArg → "--" ArgName "=" CLIValue ;
+    if (arg.startsWith('--') && arg.includes('=')) {
+        // we're dealing with an EqualsArg, we have a special helper for that
+        const [originalArg, value] = parseEqualsArg(arg);
+        setCLIArg(flags, arg.split('=')[0], normalizeFlagName(originalArg), value);
+    }
+    // AliasEqualsArg  → "-" AliasName "=" CLIValue ;
+    else if (arg.startsWith('-') && arg.includes('=')) {
+        // we're dealing with an AliasEqualsArg, we have a special helper for that
+        const [originalArg, value] = parseEqualsArg(arg);
+        setCLIArg(flags, arg.split('=')[0], normalizeFlagName(originalArg), value);
+    }
+    // AliasArg → "-" AliasName ( " " CLIValue )? ;
+    else if (CLI_FLAG_REGEX.test(arg)) {
+        // this is a short alias, like `-c` for Config
+        setCLIArg(flags, arg, normalizeFlagName(arg), parseCLIValue(args));
+    }
+    // NegativeDashArg → "--no-" ArgName ;
+    else if (arg.startsWith('--no-') && arg.length > '--no-'.length) {
+        // this is a `NegativeDashArg` term, so we need to normalize the negative
+        // flag name and then set an appropriate value
+        const normalized = normalizeNegativeFlagName(arg);
+        setCLIArg(flags, arg, normalized, '');
+    }
+    // NegativeArg → "--no" ArgName ;
+    else if (arg.startsWith('--no') &&
+        !readOnlyArrayHasStringMember(BOOLEAN_CLI_FLAGS, normalizeFlagName(arg)) &&
+        readOnlyArrayHasStringMember(BOOLEAN_CLI_FLAGS, normalizeNegativeFlagName(arg))) {
+        // possibly dealing with a `NegativeArg` here. There is a little ambiguity
+        // here because we have arguments that already begin with `no` like
+        // `notify`, so we need to test if a normalized form of the raw argument is
+        // a valid and supported boolean flag.
+        setCLIArg(flags, arg, normalizeNegativeFlagName(arg), '');
+    }
+    // SimpleArg → "--" ArgName ( " " CLIValue )? ;
+    else if (arg.startsWith('--') && arg.length > '--'.length) {
+        setCLIArg(flags, arg, normalizeFlagName(arg), parseCLIValue(args));
+    }
+    // if we get here it is not an argument in our list of supported arguments.
+    // This doesn't necessarily mean we want to report an error or anything
+    // though! Instead, with unknown / unrecognized arguments we stick them into
+    // the `unknownArgs` array, which is used when we pass CLI args to Jest, for
+    // instance. So we just return void here.
 };
 /**
- * Parse a string CLI argument
+ * Normalize a 'negative' flag name, just to do a little pre-processing before
+ * we pass it to `setCLIArg`.
  *
- * @param flags the config flags object, while we'll modify
- * @param args our CLI arguments
- * @param configCaseName the argument we want to look at right now
+ * @param flagName the flag name to normalize
+ * @returns a normalized flag name
  */
-const parseStringArg = (flags, args, configCaseName) => {
-    if (typeof flags[configCaseName] !== 'string') {
-        flags[configCaseName] = null;
-    }
-    const { value, matchingArg } = getValue(args, configCaseName);
-    if (value !== undefined && matchingArg !== undefined) {
-        flags[configCaseName] = value;
-        flags.knownArgs.push(matchingArg);
-        flags.knownArgs.push(value);
-    }
+const normalizeNegativeFlagName = (flagName) => {
+    const trimmed = flagName.replace(/^--no[-]?/, '');
+    return normalizeFlagName(trimmed.charAt(0).toLowerCase() + trimmed.slice(1));
 };
 /**
- * Parse a number CLI argument
+ * Normalize a flag name by:
+ *
+ * - replacing any leading dashes (`--foo` -> `foo`)
+ * - converting `dash-case` to camelCase (if necessary)
+ *
+ * Normalizing in this context basically means converting the various
+ * supported flag spelling variants to the variant defined in our lists of
+ * supported arguments (e.g. BOOLEAN_CLI_FLAGS, etc). So, for instance,
+ * `--log-level` should be converted to `logLevel`.
+ *
+ * @param flagName the flag name to normalize
+ * @returns a normalized flag name
  *
- * @param flags the config flags object, while we'll modify
- * @param args our CLI arguments
- * @param configCaseName the argument we want to look at right now
  */
-const parseNumberArg = (flags, args, configCaseName) => {
-    if (typeof flags[configCaseName] !== 'number') {
-        flags[configCaseName] = null;
-    }
-    const { value, matchingArg } = getValue(args, configCaseName);
-    if (value !== undefined && matchingArg !== undefined) {
-        flags[configCaseName] = parseInt(value, 10);
-        flags.knownArgs.push(matchingArg);
-        flags.knownArgs.push(value);
-    }
+const normalizeFlagName = (flagName) => {
+    const trimmed = flagName.replace(/^-+/, '');
+    return trimmed.includes('-') ? toCamelCase(trimmed) : trimmed;
 };
 /**
- * Parse a CLI argument which may be either a string or a number
- *
- * @param flags the config flags object, while we'll modify
- * @param args our CLI arguments
- * @param configCaseName the argument we want to look at right now
- */
-const parseStringNumberArg = (flags, args, configCaseName) => {
-    if (!['number', 'string'].includes(typeof flags[configCaseName])) {
-        flags[configCaseName] = null;
+ * Set a value on a provided {@link ConfigFlags} object, given an argument
+ * name and a raw string value. This function dispatches to other functions
+ * which make sure that the string value can be properly parsed into a JS
+ * runtime value of the right type (e.g. number, string, etc).
+ *
+ * @throws if a value cannot be parsed to the right type for a given flag
+ * @param flags a {@link ConfigFlags} object
+ * @param rawArg the raw argument name matched by the parser
+ * @param normalizedArg an argument with leading control characters (`--`,
+ * `--no-`, etc) removed
+ * @param value the raw value to be set onto the config flags object
+ */
+const setCLIArg = (flags, rawArg, normalizedArg, value) => {
+    normalizedArg = dereferenceAlias(normalizedArg);
+    // We're setting a boolean!
+    if (readOnlyArrayHasStringMember(BOOLEAN_CLI_FLAGS, normalizedArg)) {
+        flags[normalizedArg] =
+            typeof value === 'string'
+                ? Boolean(value)
+                : // no value was supplied, default to true
+                    true;
+        flags.knownArgs.push(rawArg);
+    }
+    // We're setting a string!
+    else if (readOnlyArrayHasStringMember(STRING_CLI_FLAGS, normalizedArg)) {
+        if (typeof value === 'string') {
+            flags[normalizedArg] = value;
+            flags.knownArgs.push(rawArg);
+            flags.knownArgs.push(value);
+        }
+        else {
+            throwCLIParsingError(rawArg, 'expected a string argument but received nothing');
+        }
+    }
+    // We're setting a string, but it's one where the user can pass multiple values,
+    // like `--reporters="default" --reporters="jest-junit"`
+    else if (readOnlyArrayHasStringMember(STRING_ARRAY_CLI_FLAGS, normalizedArg)) {
+        if (typeof value === 'string') {
+            if (!Array.isArray(flags[normalizedArg])) {
+                flags[normalizedArg] = [];
+            }
+            const targetArray = flags[normalizedArg];
+            // this is irritating, but TS doesn't know that the `!Array.isArray`
+            // check above guarantees we have an array to work with here, and it
+            // doesn't want to narrow the type of `flags[normalizedArg]`, so we need
+            // to grab a reference to that array and then `Array.isArray` that. Bah!
+            if (Array.isArray(targetArray)) {
+                targetArray.push(value);
+                flags.knownArgs.push(rawArg);
+                flags.knownArgs.push(value);
+            }
+        }
+        else {
+            throwCLIParsingError(rawArg, 'expected a string argument but received nothing');
+        }
     }
-    const { value, matchingArg } = getValue(args, configCaseName);
-    if (value !== undefined && matchingArg !== undefined) {
-        if (CLI_ARG_STRING_REGEX.test(value)) {
-            // if it matches the regex we treat it like a string
-            flags[configCaseName] = value;
+    // We're setting a number!
+    else if (readOnlyArrayHasStringMember(NUMBER_CLI_FLAGS, normalizedArg)) {
+        if (typeof value === 'string') {
+            const parsed = parseInt(value, 10);
+            if (isNaN(parsed)) {
+                throwNumberParsingError(rawArg, value);
+            }
+            else {
+                flags[normalizedArg] = parsed;
+                flags.knownArgs.push(rawArg);
+                flags.knownArgs.push(value);
+            }
         }
         else {
-            // it was a number, great!
-            flags[configCaseName] = Number(value);
+            throwCLIParsingError(rawArg, 'expected a number argument but received nothing');
+        }
+    }
+    // We're setting a value which could be either a string _or_ a number
+    else if (readOnlyArrayHasStringMember(STRING_NUMBER_CLI_FLAGS, normalizedArg)) {
+        if (typeof value === 'string') {
+            if (CLI_ARG_STRING_REGEX.test(value)) {
+                // if it matches the regex we treat it like a string
+                flags[normalizedArg] = value;
+            }
+            else {
+                const parsed = Number(value);
+                if (isNaN(parsed)) {
+                    // parsing didn't go so well, we gotta get out of here
+                    // this is unlikely given our regex guard above
+                    // but hey, this is ultimately JS so let's be safe
+                    throwNumberParsingError(rawArg, value);
+                }
+                else {
+                    flags[normalizedArg] = parsed;
+                }
+            }
+            flags.knownArgs.push(rawArg);
+            flags.knownArgs.push(value);
+        }
+        else {
+            throwCLIParsingError(rawArg, 'expected a string or a number but received nothing');
+        }
+    }
+    // We're setting the log level, which can only be a set of specific string values
+    else if (readOnlyArrayHasStringMember(LOG_LEVEL_CLI_FLAGS, normalizedArg)) {
+        if (typeof value === 'string') {
+            if (isLogLevel(value)) {
+                flags[normalizedArg] = value;
+                flags.knownArgs.push(rawArg);
+                flags.knownArgs.push(value);
+            }
+            else {
+                throwCLIParsingError(rawArg, `expected to receive a valid log level but received "${String(value)}"`);
+            }
+        }
+        else {
+            throwCLIParsingError(rawArg, 'expected to receive a valid log level but received nothing');
         }
-        flags.knownArgs.push(matchingArg);
-        flags.knownArgs.push(value);
     }
 };
 /**
@@ -722,73 +871,34 @@ const parseStringNumberArg = (flags, args, configCaseName) => {
  * to a number.
  */
 const CLI_ARG_STRING_REGEX = /[^\d\.Ee\+\-]+/g;
-/**
- * Parse a LogLevel CLI argument. These can be only a specific
- * set of strings, so this function takes care of validating that
- * the value is correct.
- *
- * @param flags the config flags object, while we'll modify
- * @param args our CLI arguments
- * @param configCaseName the argument we want to look at right now
- */
-const parseLogLevelArg = (flags, args, configCaseName) => {
-    if (typeof flags[configCaseName] !== 'string') {
-        flags[configCaseName] = null;
-    }
-    const { value, matchingArg } = getValue(args, configCaseName);
-    if (value !== undefined && matchingArg !== undefined && isLogLevel(value)) {
-        flags[configCaseName] = value;
-        flags.knownArgs.push(matchingArg);
-        flags.knownArgs.push(value);
-    }
-};
-/**
- * Helper for pulling values out from the raw array of CLI arguments. This logic
- * is shared between a few different types of CLI args.
- *
- * We look for arguments in the following formats:
- *
- * - `--my-cli-argument value`
- * - `--my-cli-argument=value`
- * - `--myCliArgument value`
- * - `--myCliArgument=value`
- *
- * We also check for shortened aliases, which we define for a few arguments.
- *
- * @param args the CLI args we're dealing with
- * @param configCaseName the ConfigFlag key which we're looking to pull out a value for
- * @returns the value for the flag as well as the exact string which it matched from
- * the user input.
- */
-const getValue = (args, configCaseName) => {
-    // for some CLI args we have a short alias, like 'c' for 'config'
-    const alias = CLI_ARG_ALIASES[configCaseName];
-    // we support supplying arguments in both dash-case and configCase
-    // for ease of use
-    const dashCaseName = toDashCase(configCaseName);
-    let value;
-    let matchingArg;
-    args.forEach((arg, i) => {
-        if (arg.startsWith(`--${dashCaseName}=`) || arg.startsWith(`--${configCaseName}=`)) {
-            // our argument was passed at the command-line in the format --argName=arg-value
-            [matchingArg, value] = parseEqualsArg(arg);
+const Empty = Symbol('Empty');
+/**
+ * A little helper which tries to parse a CLI value (as opposed to a flag) off
+ * of the argument array.
+ *
+ * We support a variety of different argument formats, but all of them start
+ * with `-`, so we can check the first character to test whether the next token
+ * in our array of CLI arguments is a flag name or a value.
+ *
+ * @param args an array of CLI args
+ * @returns either a string result or an Empty sentinel
+ */
+const parseCLIValue = (args) => {
+    // it's possible the arguments array is empty, if so, return empty
+    if (args[0] === undefined) {
+        return Empty;
+    }
+    // all we're concerned with here is that it does not start with `"-"`,
+    // which would indicate it should be parsed as a CLI flag and not a value.
+    if (!args[0].startsWith('-')) {
+        // It's not a flag, so we return the value and defer any specific parsing
+        // until later on.
+        const value = args.shift();
+        if (typeof value === 'string') {
+            return value;
         }
-        else if (arg === `--${dashCaseName}` || arg === `--${configCaseName}`) {
-            // the next value in the array is assumed to be a value for this argument
-            value = args[i + 1];
-            matchingArg = arg;
-        }
-        else if (alias) {
-            if (arg.startsWith(`-${alias}=`)) {
-                [matchingArg, value] = parseEqualsArg(arg);
-            }
-            else if (arg === `-${alias}`) {
-                value = args[i + 1];
-                matchingArg = arg;
-            }
-        }
-    });
-    return { value, matchingArg };
+    }
+    return Empty;
 };
 /**
  * Parse an 'equals' argument, which is a CLI argument-value pair in the
@@ -824,8 +934,9 @@ const getValue = (args, configCaseName) => {
  * @returns a tuple containing the arg name and the value (if present)
  */
 const parseEqualsArg = (arg) => {
-    const [originalArg, ...value] = arg.split('=');
-    return [originalArg, value.join('=')];
+    const [originalArg, ...splitSections] = arg.split('=');
+    const value = splitSections.join('=');
+    return [originalArg, value === '' ? Empty : value];
 };
 /**
  * Small helper for getting type-system-level assurance that a `string` can be
@@ -835,11 +946,50 @@ const parseEqualsArg = (arg) => {
  * @returns whether this is a `LogLevel`
  */
 const isLogLevel = (maybeLogLevel) => readOnlyArrayHasStringMember(LOG_LEVELS, maybeLogLevel);
+/**
+ * A little helper for constructing and throwing an error message with info
+ * about what went wrong
+ *
+ * @param flag the flag which encountered the error
+ * @param message a message specific to the error which was encountered
+ */
+const throwCLIParsingError = (flag, message) => {
+    throw new Error(`when parsing CLI flag "${flag}": ${message}`);
+};
+/**
+ * Throw a specific error for the situation where we ran into an issue parsing
+ * a number.
+ *
+ * @param flag the flag for which we encountered the issue
+ * @param value what we were trying to parse
+ */
+const throwNumberParsingError = (flag, value) => {
+    throwCLIParsingError(flag, `expected a number but received "${value}"`);
+};
+/**
+ * A little helper to 'dereference' a flag alias, which if you squint a little
+ * you can think of like a pointer to a full flag name. Thus 'c' is like a
+ * pointer to 'config', so here we're doing something like `*c`. Of course, this
+ * being JS, this is just a metaphor!
+ *
+ * If no 'dereference' is found for the possible alias we just return the
+ * passed string unmodified.
+ *
+ * @param maybeAlias a string which _could_ be an alias to a full flag name
+ * @returns the full aliased flag name, if found, or the passed string if not
+ */
+const dereferenceAlias = (maybeAlias) => {
+    const possibleDereference = CLI_FLAG_ALIASES[maybeAlias];
+    if (typeof possibleDereference === 'string') {
+        return possibleDereference;
+    }
+    return maybeAlias;
+};
 
 const dependencies = [
 	{
 		name: "@stencil/core",
-		version: "2.19.2",
+		version: "2.19.3",
 		main: "compiler/stencil.js",
 		resources: [
 			"package.json",
@@ -1586,7 +1736,16 @@ const CONFIG_PROPS_TO_ANONYMIZE = [
 // Props we delete entirely from the config for telemetry
 //
 // TODO(STENCIL-469): Investigate improving anonymization for tsCompilerOptions and devServer
-const CONFIG_PROPS_TO_DELETE = ['sys', 'logger', 'tsCompilerOptions', 'devServer'];
+const CONFIG_PROPS_TO_DELETE = [
+    'commonjs',
+    'devServer',
+    'env',
+    'logger',
+    'rollupConfig',
+    'sys',
+    'testing',
+    'tsCompilerOptions',
+];
 /**
  * Anonymize the config for telemetry, replacing potentially revealing config props
  * with a placeholder string if they are present (this lets us still track how frequently
@@ -1897,13 +2056,24 @@ const taskGenerate = async (coreCompiler, config) => {
     const { prompt } = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('../sys/node/prompts.js')); });
     const input = config.flags.unknownArgs.find((arg) => !arg.startsWith('-')) ||
         (await prompt({ name: 'tagName', type: 'text', message: 'Component tag name (dash-case):' })).tagName;
+    if (undefined === input) {
+        // in some shells (e.g. Windows PowerShell), hitting Ctrl+C results in a TypeError printed to the console.
+        // explicitly return here to avoid printing the error message.
+        return;
+    }
     const { dir, base: componentName } = path.parse(input);
     const tagError = validateComponentTag(componentName);
     if (tagError) {
         config.logger.error(tagError);
         return config.sys.exit(1);
     }
-    const extensionsToGenerate = ['tsx', ...(await chooseFilesToGenerate())];
+    const filesToGenerateExt = await chooseFilesToGenerate();
+    if (undefined === filesToGenerateExt) {
+        // in some shells (e.g. Windows PowerShell), hitting Ctrl+C results in a TypeError printed to the console.
+        // explicitly return here to avoid printing the error message.
+        return;
+    }
+    const extensionsToGenerate = ['tsx', ...filesToGenerateExt];
     const testFolder = extensionsToGenerate.some(isTest) ? 'test' : '';
     const outDir = path.join(absoluteSrcDir, 'components', dir, componentName);
     await config.sys.createDir(path.join(outDir, testFolder), { recursive: true });