@rindo/core 2.18.0 → 2.22.3

package/cli/index.cjs

@@ -1,5 +1,5 @@
 /*!
- Rindo CLI (CommonJS) v2.18.0 | MIT Licensed | https://rindojs.web.app
+ Rindo CLI (CommonJS) v2.22.3 | MIT Licensed | https://rindojs.web.app
  */
 'use strict';
 
@@ -25,41 +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
- *
- * @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!)
@@ -72,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';
 
@@ -297,6 +272,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,10 +332,33 @@ 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 Rindo CLI
  */
-const BOOLEAN_CLI_ARGS = [
+const BOOLEAN_CLI_FLAGS = [
     'build',
     'cache',
     'checkVersion',
@@ -427,7 +441,7 @@ const BOOLEAN_CLI_ARGS = [
 /**
  * All the Number options supported by the Rindo CLI
  */
-const NUMBER_CLI_ARGS = [
+const NUMBER_CLI_FLAGS = [
     'port',
     // JEST CLI ARGS
     'maxConcurrency',
@@ -436,7 +450,7 @@ const NUMBER_CLI_ARGS = [
 /**
  * All the String options supported by the Rindo CLI
  */
-const STRING_CLI_ARGS = [
+const STRING_CLI_FLAGS = [
     'address',
     'config',
     'docsApi',
@@ -475,7 +489,8 @@ const STRING_CLI_ARGS = [
     'testURL',
     'timers',
     'transform',
-    // ARRAY ARGS
+];
+const STRING_ARRAY_CLI_FLAGS = [
     'collectCoverageOnlyFrom',
     'coveragePathIgnorePatterns',
     'coverageReporters',
@@ -504,7 +519,7 @@ const STRING_CLI_ARGS = [
  * `maxWorkers` is an argument which is used both by Rindo _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 Rindo CLI
  *
@@ -512,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!
@@ -554,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) {
@@ -572,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
- */
-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);
-        }
-    });
+ * @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 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
+ * 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).
  *
- * @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;
+ * @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');
+        }
     }
-    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 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 {
-            // it was a number, great!
-            flags[configCaseName] = Number(value);
+            throwCLIParsingError(rawArg, 'expected a string argument but received nothing');
+        }
+    }
+    // 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 {
+            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);
     }
 };
 /**
@@ -706,73 +871,34 @@ const parseStringNumberArg = (flags, args, configCaseName) => {
  * to a number.
  */
 const CLI_ARG_STRING_REGEX = /[^\d\.Ee\+\-]+/g;
+const Empty = Symbol('Empty');
 /**
- * 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.
+ * A little helper which tries to parse a CLI value (as opposed to a flag) off
+ * of the argument array.
  *
- * @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);
-        }
-        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;
-            }
+ * 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;
         }
-    });
-    return { value, matchingArg };
+    }
+    return Empty;
 };
 /**
  * Parse an 'equals' argument, which is a CLI argument-value pair in the
@@ -808,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
@@ -818,18 +945,51 @@ 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);
+/**
+ * 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: "@rindo/core",
-		version: "2.18.0",
+		version: "2.22.3",
 		main: "compiler/rindo.js",
 		resources: [
 			"package.json",
@@ -866,6 +1026,7 @@ const dependencies = [
 			"compiler/lib.es2019.array.d.ts",
 			"compiler/lib.es2019.d.ts",
 			"compiler/lib.es2019.full.d.ts",
+			"compiler/lib.es2019.intl.d.ts",
 			"compiler/lib.es2019.object.d.ts",
 			"compiler/lib.es2019.string.d.ts",
 			"compiler/lib.es2019.symbol.d.ts",
@@ -891,6 +1052,7 @@ const dependencies = [
 			"compiler/lib.es2022.full.d.ts",
 			"compiler/lib.es2022.intl.d.ts",
 			"compiler/lib.es2022.object.d.ts",
+			"compiler/lib.es2022.sharedmemory.d.ts",
 			"compiler/lib.es2022.string.d.ts",
 			"compiler/lib.es5.d.ts",
 			"compiler/lib.es6.d.ts",
@@ -936,16 +1098,112 @@ const dependencies = [
 	},
 	{
 		name: "terser",
-		version: "5.6.1",
+		version: "5.16.1",
 		main: "dist/bundle.min.js"
 	},
 	{
 		name: "typescript",
-		version: "4.7.4",
+		version: "4.9.4",
 		main: "lib/typescript.js"
 	}
 ];
 
+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 Rindo configuration file on the file system
  * @param opts the options needed to find the configuration file
@@ -954,11 +1212,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 +1227,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 +1266,33 @@ const loadCoreCompiler = async (sys) => {
     return globalThis.rindo;
 };
 
+/**
+ * Log the name of this package (`@rindo/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(`@rindo/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 +1308,25 @@ const startupLogVersion = (logger, task, coreCompiler) => {
     startupMsg += logger.emoji(' ' + coreCompiler.vermoji);
     logger.info(startupMsg);
 };
+/**
+ * Log details from a {@link CompilerSystem} used by Rindo 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 Rindo
+ * @param coreCompiler the compiler instance being used for this invocation of Rindo
+ */
 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 +1340,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 Rindo
+ * @param config a validated configuration object to be used for this run of Rindo
+ */
 const startupCompilerLog = (coreCompiler, config) => {
     if (config.suppressLogs === true) {
         return;
@@ -1067,6 +1369,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 +1415,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 +1461,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,12 +1483,12 @@ 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;
 };
 const UUID_REGEX = new RegExp(/^[0-9A-F]{8}-[0-9A-F]{4}-4[0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}$/i);
-// Plucked from https://github.com/navify/jigra/blob/HEAD/cli/src/util/uuid.ts
+// Plucked from https://github.com/familyjs/jigra/blob/HEAD/cli/src/util/uuid.ts
 function uuidv4() {
     return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
         const r = (Math.random() * 16) | 0;
@@ -1201,7 +1512,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,25 +1520,14 @@ 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 Rindo 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;
-const defaultConfig = (sys) => sys.resolvePath(`${sys.homeDir()}/.navify/${isTest$1() ? 'tmp-config.json' : 'config.json'}`);
-const defaultConfigDirectory = (sys) => sys.resolvePath(`${sys.homeDir()}/.navify`);
+const defaultConfig = (sys) => sys.resolvePath(`${sys.homeDir()}/.family/${isTest$1() ? 'tmp-config.json' : 'config.json'}`);
+const defaultConfigDirectory = (sys) => sys.resolvePath(`${sys.homeDir()}/.family`);
 /**
- * Reads an Navify configuration file from disk, parses it, and performs any necessary corrections to it if certain
+ * Reads an Family configuration file from disk, parses it, and performs any necessary corrections to it if certain
  * values are deemed to be malformed
  * @param sys The system where the command is invoked
  * @returns the config read from disk that has been potentially been updated
@@ -1241,7 +1541,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;
@@ -1249,7 +1549,7 @@ async function readConfig(sys) {
     return config;
 }
 /**
- * Writes an Navify configuration file to disk.
+ * Writes an Family configuration file to disk.
  * @param sys The system where the command is invoked
  * @param config The config passed into the Rindo command
  * @returns boolean If the command was successful
@@ -1267,7 +1567,7 @@ async function writeConfig(sys, config) {
     return result;
 }
 /**
- * Update a subset of the Navify config.
+ * Update a subset of the Family config.
  * @param sys The system where the command is invoked
  * @param newOptions The new options to save
  * @returns boolean If the command was successful
@@ -1277,14 +1577,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 Rindo 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 +1597,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, 'rindo_cli_command', data);
     config.logger.debug(`${config.logger.blue('Telemetry')}: ${config.logger.gray(JSON.stringify(data))}`);
@@ -1378,38 +1680,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 rindo = 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,
         rindo,
         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
@@ -1433,7 +1738,16 @@ const CONFIG_PROPS_TO_ANONYMIZE = [
 // Props we delete entirely from the config for telemetry
 //
 // TODO: 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
@@ -1483,7 +1797,7 @@ const anonymizeConfigForTelemetry = (config) => {
 /**
  * Reads package-lock.json, yarn.lock, and package.json files in order to cross-reference
  * the dependencies and devDependencies properties. Pulls up the current installed version
- * of each package under the @rindo, @navify, and @jigra scopes.
+ * of each package under the @rindo, @familyjs, and @jigra scopes.
  *
  * @param sys the system instance where telemetry is invoked
  * @param config the Rindo configuration associated with the current task that triggered telemetry
@@ -1505,16 +1819,16 @@ async function getInstalledPackages(sys, config) {
             ...packageJson.devDependencies,
             ...packageJson.dependencies,
         });
-        // Collect packages only in the rindo, navify, or jigra org's:
+        // Collect packages only in the rindo, familyjs, or jigra org's:
         // https://www.npmjs.com/org/rindo
-        const navifyPackages = rawPackages.filter(([k]) => k.startsWith('@rindo/') || k.startsWith('@navify/') || k.startsWith('@jigra/'));
+        const familyPackages = rawPackages.filter(([k]) => k.startsWith('@rindo/') || k.startsWith('@familyjs/') || k.startsWith('@jigra/'));
         try {
-            packages = yarn ? await yarnPackages(sys, navifyPackages) : await npmPackages(sys, navifyPackages);
+            packages = yarn ? await yarnPackages(sys, familyPackages) : await npmPackages(sys, familyPackages);
         }
         catch (e) {
-            packages = navifyPackages.map(([k, v]) => `${k}@${v.replace('^', '')}`);
+            packages = familyPackages.map(([k, v]) => `${k}@${v.replace('^', '')}`);
         }
-        packagesNoVersions = navifyPackages.map(([k]) => `${k}`);
+        packagesNoVersions = familyPackages.map(([k]) => `${k}`);
         return { packages, packagesNoVersions };
     }
     catch (err) {
@@ -1525,13 +1839,13 @@ async function getInstalledPackages(sys, config) {
 /**
  * Visits the npm lock file to find the exact versions that are installed
  * @param sys The system where the command is invoked
- * @param navifyPackages a list of the found packages matching `@rindo`, `@jigra`, or `@navify` from the package.json file.
+ * @param familyPackages a list of the found packages matching `@rindo`, `@jigra`, or `@familyjs` from the package.json file.
  * @returns an array of strings of all the packages and their versions.
  */
-async function npmPackages(sys, navifyPackages) {
+async function npmPackages(sys, familyPackages) {
     const appRootDir = sys.getCurrentDirectory();
     const packageLockJson = await tryFn(readJson, sys, sys.resolvePath(appRootDir + '/package-lock.json'));
-    return navifyPackages.map(([k, v]) => {
+    return familyPackages.map(([k, v]) => {
         var _a, _b, _c, _d;
         let version = (_d = (_b = (_a = packageLockJson === null || packageLockJson === void 0 ? void 0 : packageLockJson.dependencies[k]) === null || _a === void 0 ? void 0 : _a.version) !== null && _b !== void 0 ? _b : (_c = packageLockJson === null || packageLockJson === void 0 ? void 0 : packageLockJson.devDependencies[k]) === null || _c === void 0 ? void 0 : _c.version) !== null && _d !== void 0 ? _d : v;
         version = version.includes('file:') ? sanitizeDeclaredVersion(v) : version;
@@ -1541,14 +1855,14 @@ async function npmPackages(sys, navifyPackages) {
 /**
  * Visits the yarn lock file to find the exact versions that are installed
  * @param sys The system where the command is invoked
- * @param navifyPackages a list of the found packages matching `@rindo`, `@jigra`, or `@navify` from the package.json file.
+ * @param familyPackages a list of the found packages matching `@rindo`, `@jigra`, or `@familyjs` from the package.json file.
  * @returns an array of strings of all the packages and their versions.
  */
-async function yarnPackages(sys, navifyPackages) {
+async function yarnPackages(sys, familyPackages) {
     const appRootDir = sys.getCurrentDirectory();
     const yarnLock = sys.readFileSync(sys.resolvePath(appRootDir + '/yarn.lock'));
     const yarnLockYml = sys.parseYarnLockFile(yarnLock);
-    return navifyPackages.map(([k, v]) => {
+    return familyPackages.map(([k, v]) => {
         var _a;
         const identifiedVersion = `${k}@${v}`;
         let version = (_a = yarnLockYml.object[identifiedVersion]) === null || _a === void 0 ? void 0 : _a.version;
@@ -1613,7 +1927,7 @@ async function sendTelemetry(sys, config, data) {
             sent_at: now,
         };
         // This request is only made if telemetry is on.
-        const response = await sys.fetch('https://api-navifyjs.web.app/events/metrics', {
+        const response = await sys.fetch('https://familyjs-api.web.app/events/metrics', {
             method: 'POST',
             headers: {
                 'Content-Type': 'application/json',
@@ -1716,13 +2030,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
@@ -1751,13 +2058,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 });
@@ -1981,7 +2299,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://rindojs.web.app/telemetry')}`;
+    const INFORMATION = `Opt in or out of telemetry. Information about the data we collect is available on our website: ${logger.bold('https://rindojs.web.app/telemetry')}`;
     const THANK_YOU = `Thank you for helping to make Rindo better! 💖`;
     const ENABLED_MESSAGE = `${logger.green('Enabled')}. ${THANK_YOU}\n\n`;
     const DISABLED_MESSAGE = `${logger.red('Disabled')}\n\n`;
@@ -2104,93 +2422,54 @@ const taskServe = async (config) => {
 };
 
 /**
- * Creates an instance of a logger
- * @returns the new logger instance
+ * Entrypoint for any Rindo tests
+ * @param config a validated Rindo configuration entity
  */
-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 taskTest = async (config) => {
+    if (!IS_NODE_ENV) {
+        config.logger.error(`"test" command is currently only implemented for a NodeJS environment`);
+        return config.sys.exit(1);
     }
-    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;
-            }
+    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.`));
         }
-        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);
+    // 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);
     }
-    else if (diagnostic.level === 'warn') {
-        console.warn(msg);
+    try {
+        // let's test!
+        const { createTesting } = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('../testing/index.js')); });
+        const testing = await createTesting(config);
+        const passed = await testing.run(testingRunOpts);
+        await testing.destroy();
+        if (!passed) {
+            return config.sys.exit(1);
+        }
     }
-    else {
-        console.log(msg);
+    catch (e) {
+        config.logger.error(e);
+        return config.sys.exit(1);
     }
-};
-const YELLOW = `#f39c12`;
-const RED = `#c0392b`;
-const BLUE = `#3498db`;
+};
 
 const run = async (init) => {
     const { args, logger, sys } = init;
@@ -2206,7 +2485,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;
         }
@@ -2309,6 +2588,9 @@ const runTask = async (coreCompiler, config, task, sys) => {
         case 'telemetry':
             await taskTelemetry(strictConfig.flags, sys, strictConfig.logger);
             break;
+        case 'test':
+            await taskTest(strictConfig);
+            break;
         case 'version':
             console.log(coreCompiler.version);
             break;