@rindo/core 2.17.2-0 → 2.17.3

package/cli/index.cjs

@@ -1,5 +1,5 @@
 /*!
- Rindo CLI (CommonJS) v2.17.2-0 | MIT Licensed | https://rindojs.web.app
+ Rindo CLI (CommonJS) v2.17.3 | MIT Licensed | https://rindojs.web.app
  */
 'use strict';
 
@@ -543,11 +543,12 @@ const createConfigFlags = (init = {}) => {
 /**
  * Parse command line arguments into a structured `ConfigFlags` object
  *
- * @param args an array of config flags
- * @param sys an optional compiler system
+ * @param args an array of CLI flags
+ * @param _sys an optional compiler system
  * @returns a structured ConfigFlags object
  */
-const parseFlags = (args, sys) => {
+const parseFlags = (args, _sys) => {
+    // TODO: 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() : [];
@@ -555,24 +556,19 @@ const parseFlags = (args, sys) => {
         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;
 };
 /**
@@ -758,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];
@@ -779,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:
+ *
+ * ```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 commandArgument the arg in question
- * @returns the value after the `=`
+ * @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`
@@ -799,28 +824,12 @@ const isLogLevel = (maybeLogLevel) =>
 // `ReadonlyArray` 😢 thus we `as any`
 //
 // 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;
-};
+LOG_LEVELS.includes(maybeLogLevel);
 
 const dependencies = [
 	{
 		name: "@rindo/core",
-		version: "2.17.2-0",
+		version: "2.17.3",
 		main: "compiler/rindo.js",
 		resources: [
 			"package.json",
@@ -1316,6 +1325,15 @@ async function telemetryAction(sys, config, coreCompiler, action) {
         throw error;
     }
 }
+/**
+ * Helper function to determine if a Rindo configuration builds an application.
+ *
+ * This function is a rough approximation whether an application is generated as a part of a Rindo build, based on
+ * contents of the project's `rindo.config.ts` file.
+ *
+ * @param config the configuration used by the Rindo 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 !== '/')));
 }
@@ -1323,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 Rindo configuration.
+ *
+ * Duplicate entries will not be returned from the list
+ *
+ * @param config the configuration used by the Rindo project
+ * @returns a unique list of output target types found in the Rindo configuration
+ */
+function getActiveTargets(config) {
     const result = config.outputTargets.map((t) => t.type);
     return Array.from(new Set(result));
 }
@@ -1340,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 rindo = coreCompiler.version || 'unknown';
     const system = `${sys.name} ${sys.version}`;
@@ -1403,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
@@ -1631,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);
@@ -1644,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: 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;
@@ -2011,10 +2033,7 @@ const taskHelp = async (flags, logger, sys) => {
     ${prompt} ${logger.green('rindo generate')} or ${logger.green('rindo g')}
 
 `);
-    // TODO: 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:')}
 
@@ -2162,7 +2181,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');
@@ -2200,9 +2219,7 @@ const run = async (init) => {
         startupLogVersion(logger, task, coreCompiler);
         loadedCompilerLog(sys, logger, flags, coreCompiler);
         if (task === 'info') {
-            await telemetryAction(sys, { flags: createConfigFlags({ task: 'info' }), logger }, coreCompiler, async () => {
-                await taskInfo(coreCompiler, sys, logger);
-            });
+            taskInfo(coreCompiler, sys, logger);
             return;
         }
         const validated = await coreCompiler.loadConfig({
@@ -2235,14 +2252,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 Rindo 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: createConfigFlags((_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);
@@ -2261,10 +2291,7 @@ const runTask = async (coreCompiler, config, task, sys) => {
             await taskServe(strictConfig);
             break;
         case 'telemetry':
-            // TODO: 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 'version':
             console.log(coreCompiler.version);

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 };

package/cli/index.js

@@ -1,5 +1,5 @@
 /*!
- Rindo CLI v2.17.2-0 | MIT Licensed | https://rindojs.web.app
+ Rindo CLI v2.17.3 | MIT Licensed | https://rindojs.web.app
  */
 /**
  * This sets the log level hierarchy for our terminal logger, ranging from
@@ -519,11 +519,12 @@ const createConfigFlags = (init = {}) => {
 /**
  * Parse command line arguments into a structured `ConfigFlags` object
  *
- * @param args an array of config flags
- * @param sys an optional compiler system
+ * @param args an array of CLI flags
+ * @param _sys an optional compiler system
  * @returns a structured ConfigFlags object
  */
-const parseFlags = (args, sys) => {
+const parseFlags = (args, _sys) => {
+    // TODO: 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() : [];
@@ -531,24 +532,19 @@ const parseFlags = (args, sys) => {
         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;
 };
 /**
@@ -734,17 +730,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];
@@ -755,13 +751,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:
+ *
+ * ```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 commandArgument the arg in question
- * @returns the value after the `=`
+ * @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`
@@ -775,28 +800,12 @@ const isLogLevel = (maybeLogLevel) =>
 // `ReadonlyArray` 😢 thus we `as any`
 //
 // 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;
-};
+LOG_LEVELS.includes(maybeLogLevel);
 
 const dependencies = [
 	{
 		name: "@rindo/core",
-		version: "2.17.2-0",
+		version: "2.17.3",
 		main: "compiler/rindo.js",
 		resources: [
 			"package.json",
@@ -1292,6 +1301,15 @@ async function telemetryAction(sys, config, coreCompiler, action) {
         throw error;
     }
 }
+/**
+ * Helper function to determine if a Rindo configuration builds an application.
+ *
+ * This function is a rough approximation whether an application is generated as a part of a Rindo build, based on
+ * contents of the project's `rindo.config.ts` file.
+ *
+ * @param config the configuration used by the Rindo 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 !== '/')));
 }
@@ -1299,7 +1317,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 Rindo configuration.
+ *
+ * Duplicate entries will not be returned from the list
+ *
+ * @param config the configuration used by the Rindo project
+ * @returns a unique list of output target types found in the Rindo configuration
+ */
+function getActiveTargets(config) {
     const result = config.outputTargets.map((t) => t.type);
     return Array.from(new Set(result));
 }
@@ -1316,7 +1342,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 rindo = coreCompiler.version || 'unknown';
     const system = `${sys.name} ${sys.version}`;
@@ -1379,14 +1405,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
@@ -1607,7 +1632,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);
@@ -1620,10 +1645,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: 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;
@@ -1987,10 +2009,7 @@ const taskHelp = async (flags, logger, sys) => {
     ${prompt} ${logger.green('rindo generate')} or ${logger.green('rindo g')}
 
 `);
-    // TODO: 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:')}
 
@@ -2138,7 +2157,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');
@@ -2176,9 +2195,7 @@ const run = async (init) => {
         startupLogVersion(logger, task, coreCompiler);
         loadedCompilerLog(sys, logger, flags, coreCompiler);
         if (task === 'info') {
-            await telemetryAction(sys, { flags: createConfigFlags({ task: 'info' }), logger }, coreCompiler, async () => {
-                await taskInfo(coreCompiler, sys, logger);
-            });
+            taskInfo(coreCompiler, sys, logger);
             return;
         }
         const validated = await coreCompiler.loadConfig({
@@ -2211,14 +2228,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 Rindo 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: createConfigFlags((_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);
@@ -2237,10 +2267,7 @@ const runTask = async (coreCompiler, config, task, sys) => {
             await taskServe(strictConfig);
             break;
         case 'telemetry':
-            // TODO: 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 'version':
             console.log(coreCompiler.version);

package/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rindo/core/cli",
-  "version": "2.17.2-0",
+  "version": "2.17.3",
   "description": "Rindo CLI.",
   "main": "./index.cjs",
   "module": "./index.js",

package/compiler/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rindo/core/compiler",
-  "version": "2.17.2-0",
+  "version": "2.17.3",
   "description": "Rindo Compiler.",
   "main": "./rindo.js",
   "types": "./rindo.d.ts",