@stencil/core 2.17.1 → 2.17.3

package/cli/config-flags.d.ts

@@ -94,9 +94,17 @@ declare type LogLevelFlags = ObjectFromKeys<typeof LOG_LEVEL_CLI_ARGS, LogLevel>
  * on actual flags passed by the user.
  */
 export interface ConfigFlags extends BooleanConfigFlags, StringConfigFlags, NumberConfigFlags, StringNumberConfigFlags, LogLevelFlags {
-    task?: TaskCommand | null;
-    args?: string[];
-    knownArgs?: string[];
-    unknownArgs?: string[];
+    task: TaskCommand | null;
+    args: string[];
+    knownArgs: string[];
+    unknownArgs: string[];
 }
+/**
+ * Helper function for initializing a `ConfigFlags` object. Provide any overrides
+ * for default values and off you go!
+ *
+ * @param init an object with any overrides for default values
+ * @returns a complete CLI flag object
+ */
+export declare const createConfigFlags: (init?: Partial<ConfigFlags>) => ConfigFlags;
 export {};

package/cli/index.cjs

@@ -1,5 +1,5 @@
 /*!
- Stencil CLI (CommonJS) v2.17.1 | MIT Licensed | https://stenciljs.com
+ Stencil CLI (CommonJS) v2.17.3 | MIT Licensed | https://stenciljs.com
  */
 'use strict';
 
@@ -522,45 +522,53 @@ const CLI_ARG_ALIASES = {
     port: 'p',
     version: 'v',
 };
-
 /**
- * Parse command line arguments into a structured `ConfigFlags` object
+ * Helper function for initializing a `ConfigFlags` object. Provide any overrides
+ * for default values and off you go!
  *
- * @param args an array of config flags
- * @param sys an optional compiler system
- * @returns a structured ConfigFlags object
+ * @param init an object with any overrides for default values
+ * @returns a complete CLI flag object
  */
-const parseFlags = (args, sys) => {
+const createConfigFlags = (init = {}) => {
     const flags = {
         task: null,
         args: [],
         knownArgs: [],
         unknownArgs: [],
+        ...init,
     };
+    return flags;
+};
+
+/**
+ * Parse command line arguments into a structured `ConfigFlags` object
+ *
+ * @param args an array of CLI flags
+ * @param _sys an optional compiler system
+ * @returns a structured ConfigFlags object
+ */
+const parseFlags = (args, _sys) => {
+    // TODO(STENCIL-509): remove the _sys parameter here ^^ (for v3)
+    const flags = createConfigFlags();
     // cmd line has more priority over npm scripts cmd
     flags.args = Array.isArray(args) ? args.slice() : [];
     if (flags.args.length > 0 && flags.args[0] && !flags.args[0].startsWith('-')) {
         flags.task = flags.args[0];
     }
     parseArgs(flags, flags.args);
-    if (sys && sys.name === 'node') {
-        const envArgs = getNpmConfigEnvArgs(sys);
-        parseArgs(flags, envArgs);
-        envArgs.forEach((envArg) => {
-            if (!flags.args.includes(envArg)) {
-                flags.args.push(envArg);
-            }
-        });
-    }
     if (flags.task != null) {
         const i = flags.args.indexOf(flags.task);
         if (i > -1) {
             flags.args.splice(i, 1);
         }
     }
-    flags.unknownArgs = flags.args.filter((arg) => {
-        return !flags.knownArgs.includes(arg);
-    });
+    // to find unknown / unrecognized arguments we filter `args`, including only
+    // arguments whose normalized form is not found in `knownArgs`. `knownArgs`
+    // is populated during the call to `parseArgs` above. For arguments like
+    // `--foobar` the string `"--foobar"` will be added, while for more
+    // complicated arguments like `--bizBoz=bop` or `--bizBoz bop` just the
+    // string `"--bizBoz"` will be added.
+    flags.unknownArgs = flags.args.filter((arg) => !flags.knownArgs.includes(parseEqualsArg(arg)[0]));
     return flags;
 };
 /**
@@ -746,17 +754,17 @@ const getValue = (args, configCaseName) => {
     let matchingArg;
     args.forEach((arg, i) => {
         if (arg.startsWith(`--${dashCaseName}=`) || arg.startsWith(`--${configCaseName}=`)) {
-            value = getEqualsValue(arg);
-            matchingArg = arg;
+            // 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}=`)) {
-                value = getEqualsValue(arg);
-                matchingArg = arg;
+                [matchingArg, value] = parseEqualsArg(arg);
             }
             else if (arg === `-${alias}`) {
                 value = args[i + 1];
@@ -767,13 +775,42 @@ const getValue = (args, configCaseName) => {
     return { value, matchingArg };
 };
 /**
- * When a parameter is set in the format `--foobar=12` at the CLI (as opposed to
- * `--foobar 12`) we want to get the value after the `=` sign
+ * Parse an 'equals' argument, which is a CLI argument-value pair in the
+ * format `--foobar=12` (as opposed to a space-separated format like
+ * `--foobar 12`).
+ *
+ * To parse this we split on the `=`, returning the first part as the argument
+ * name and the second part as the value. We join the value on `"="` in case
+ * there is another `"="` in the argument.
+ *
+ * This function is safe to call with any arg, and can therefore be used as
+ * an argument 'normalizer'. If CLI argument is not an 'equals' argument then
+ * the return value will be a tuple of the original argument and an empty
+ * string `""` for the value.
+ *
+ * In code terms, if you do:
  *
- * @param commandArgument the arg in question
- * @returns the value after the `=`
+ * ```ts
+ * const [arg, value] = parseEqualsArg("--myArgument")
+ * ```
+ *
+ * Then `arg` will be `"--myArgument"` and `value` will be `""`, whereas if
+ * you do:
+ *
+ *
+ * ```ts
+ * const [arg, value] = parseEqualsArg("--myArgument=myValue")
+ * ```
+ *
+ * Then `arg` will be `"--myArgument"` and `value` will be `"myValue"`.
+ *
+ * @param arg the arg in question
+ * @returns a tuple containing the arg name and the value (if present)
  */
-const getEqualsValue = (commandArgument) => commandArgument.split('=').slice(1).join('=');
+const parseEqualsArg = (arg) => {
+    const [originalArg, ...value] = arg.split('=');
+    return [originalArg, value.join('=')];
+};
 /**
  * Small helper for getting type-system-level assurance that a `string` can be
  * narrowed to a `LogLevel`
@@ -788,27 +825,11 @@ const isLogLevel = (maybeLogLevel) =>
 //
 // see microsoft/TypeScript#31018 for some discussion of this
 LOG_LEVELS.includes(maybeLogLevel);
-const getNpmConfigEnvArgs = (sys) => {
-    // process.env.npm_config_argv
-    // {"remain":["4444"],"cooked":["run","serve","--port","4444"],"original":["run","serve","--port","4444"]}
-    let args = [];
-    try {
-        const npmConfigArgs = sys.getEnvironmentVar('npm_config_argv');
-        if (npmConfigArgs) {
-            args = JSON.parse(npmConfigArgs).original;
-            if (args[0] === 'run') {
-                args = args.slice(2);
-            }
-        }
-    }
-    catch (e) { }
-    return args;
-};
 
 const dependencies = [
 	{
 		name: "@stencil/core",
-		version: "2.17.1",
+		version: "2.17.3",
 		main: "compiler/stencil.js",
 		resources: [
 			"package.json",
@@ -1304,6 +1325,15 @@ async function telemetryAction(sys, config, coreCompiler, action) {
         throw error;
     }
 }
+/**
+ * Helper function to determine if a Stencil configuration builds an application.
+ *
+ * This function is a rough approximation whether an application is generated as a part of a Stencil build, based on
+ * contents of the project's `stencil.config.ts` file.
+ *
+ * @param config the configuration used by the Stencil project
+ * @returns true if we believe the project generates an application, false otherwise
+ */
 function hasAppTarget(config) {
     return config.outputTargets.some((target) => target.type === WWW && (!!target.serviceWorker || (!!target.baseUrl && target.baseUrl !== '/')));
 }
@@ -1311,7 +1341,15 @@ function isUsingYarn(sys) {
     var _a;
     return ((_a = sys.getEnvironmentVar('npm_execpath')) === null || _a === void 0 ? void 0 : _a.includes('yarn')) || false;
 }
-async function getActiveTargets(config) {
+/**
+ * Build a list of the different types of output targets used in a Stencil configuration.
+ *
+ * Duplicate entries will not be returned from the list
+ *
+ * @param config the configuration used by the Stencil project
+ * @returns a unique list of output target types found in the Stencil configuration
+ */
+function getActiveTargets(config) {
     const result = config.outputTargets.map((t) => t.type);
     return Array.from(new Set(result));
 }
@@ -1328,7 +1366,7 @@ async function getActiveTargets(config) {
 const prepareData = async (coreCompiler, config, sys, duration_ms, component_count = undefined) => {
     const { typescript, rollup } = coreCompiler.versions || { typescript: 'unknown', rollup: 'unknown' };
     const { packages, packagesNoVersions } = await getInstalledPackages(sys, config);
-    const targets = await getActiveTargets(config);
+    const targets = getActiveTargets(config);
     const yarn = isUsingYarn(sys);
     const stencil = coreCompiler.version || 'unknown';
     const system = `${sys.name} ${sys.version}`;
@@ -1391,14 +1429,13 @@ const CONFIG_PROPS_TO_DELETE = ['sys', 'logger', 'tsCompilerOptions', 'devServer
  * @returns an anonymized copy of the same config
  */
 const anonymizeConfigForTelemetry = (config) => {
-    var _a;
     const anonymizedConfig = { ...config };
     for (const prop of CONFIG_PROPS_TO_ANONYMIZE) {
         if (anonymizedConfig[prop] !== undefined) {
             anonymizedConfig[prop] = 'omitted';
         }
     }
-    anonymizedConfig.outputTargets = ((_a = config.outputTargets) !== null && _a !== void 0 ? _a : []).map((target) => {
+    anonymizedConfig.outputTargets = config.outputTargets.map((target) => {
         // Anonymize the outputTargets on our configuration, taking advantage of the
         // optional 2nd argument to `JSON.stringify`. If anything is not a string
         // we retain it so that any nested properties are handled, else we check
@@ -1619,7 +1656,7 @@ function getMajorVersion(version) {
     return parts[0];
 }
 
-const taskBuild = async (coreCompiler, config, sys) => {
+const taskBuild = async (coreCompiler, config) => {
     if (config.flags.watch) {
         // watch build
         await taskWatch(coreCompiler, config);
@@ -1632,10 +1669,7 @@ const taskBuild = async (coreCompiler, config, sys) => {
         const versionChecker = startCheckVersion(config, coreCompiler.version);
         const compiler = await coreCompiler.createCompiler(config);
         const results = await compiler.build();
-        // TODO(STENCIL-148) make this parameter no longer optional, remove the surrounding if statement
-        if (sys) {
-            await telemetryBuildFinishedAction(sys, config, coreCompiler, results);
-        }
+        await telemetryBuildFinishedAction(config.sys, config, coreCompiler, results);
         await compiler.destroy();
         if (results.hasError) {
             exitCode = 1;
@@ -2001,10 +2035,7 @@ const taskHelp = async (flags, logger, sys) => {
     ${prompt} ${logger.green('stencil generate')} or ${logger.green('stencil g')}
 
 `);
-    // TODO(STENCIL-148) make this parameter no longer optional, remove the surrounding if statement
-    if (sys) {
-        await taskTelemetry(flags, sys, logger);
-    }
+    await taskTelemetry(flags, sys, logger);
     console.log(`
   ${logger.bold('Examples:')}
 
@@ -2202,7 +2233,7 @@ const BLUE = `#3498db`;
 const run = async (init) => {
     const { args, logger, sys } = init;
     try {
-        const flags = parseFlags(args, sys);
+        const flags = parseFlags(args);
         const task = flags.task;
         if (flags.debug || flags.verbose) {
             logger.setLevel('debug');
@@ -2214,7 +2245,7 @@ const run = async (init) => {
             sys.applyGlobalPatch(sys.getCurrentDirectory());
         }
         if (task === 'help' || flags.help) {
-            await taskHelp({ task: 'help', args }, logger, sys);
+            await taskHelp(createConfigFlags({ task: 'help', args }), logger, sys);
             return;
         }
         startupLog(logger, task);
@@ -2240,9 +2271,7 @@ const run = async (init) => {
         startupLogVersion(logger, task, coreCompiler);
         loadedCompilerLog(sys, logger, flags, coreCompiler);
         if (task === 'info') {
-            await telemetryAction(sys, { flags: { task: 'info' }, logger }, coreCompiler, async () => {
-                await taskInfo(coreCompiler, sys, logger);
-            });
+            taskInfo(coreCompiler, sys, logger);
             return;
         }
         const validated = await coreCompiler.loadConfig({
@@ -2275,14 +2304,27 @@ const run = async (init) => {
         }
     }
 };
+/**
+ * Run a specified task
+ * @param coreCompiler an instance of a minimal, bootstrap compiler for running the specified task
+ * @param config a configuration for the Stencil project to apply to the task run
+ * @param task the task to run
+ * @param sys the {@link CompilerSystem} for interacting with the operating system
+ * @public
+ */
 const runTask = async (coreCompiler, config, task, sys) => {
-    var _a, _b;
+    var _a, _b, _c;
     const logger = (_a = config.logger) !== null && _a !== void 0 ? _a : createLogger();
-    const strictConfig = { ...config, flags: (_b = { ...config.flags }) !== null && _b !== void 0 ? _b : { task }, logger };
-    strictConfig.outputTargets = strictConfig.outputTargets || [];
+    const strictConfig = {
+        ...config,
+        flags: createConfigFlags((_b = config.flags) !== null && _b !== void 0 ? _b : { task }),
+        logger,
+        outputTargets: (_c = config.outputTargets) !== null && _c !== void 0 ? _c : [],
+        sys: sys !== null && sys !== void 0 ? sys : coreCompiler.createSystem({ logger }),
+    };
     switch (task) {
         case 'build':
-            await taskBuild(coreCompiler, strictConfig, sys);
+            await taskBuild(coreCompiler, strictConfig);
             break;
         case 'docs':
             await taskDocs(coreCompiler, strictConfig);
@@ -2301,10 +2343,7 @@ const runTask = async (coreCompiler, config, task, sys) => {
             await taskServe(strictConfig);
             break;
         case 'telemetry':
-            // TODO(STENCIL-148) make this parameter no longer optional, remove the surrounding if statement
-            if (sys) {
-                await taskTelemetry(strictConfig.flags, sys, strictConfig.logger);
-            }
+            await taskTelemetry(strictConfig.flags, sys, strictConfig.logger);
             break;
         case 'test':
             await taskTest(strictConfig);

package/cli/index.d.ts

@@ -12,5 +12,5 @@ export declare function run(init: CliInitOptions): Promise<void>;
  * @param task The task command to run, such as `build`.
  */
 export declare function runTask(coreCompiler: any, config: Config, task: TaskCommand): Promise<void>;
-export declare function parseFlags(args: string[], sys?: CompilerSystem): ConfigFlags;
+export declare function parseFlags(args: string[], _sys?: CompilerSystem): ConfigFlags;
 export { CompilerSystem, Config, ConfigFlags, Logger, TaskCommand };