@stencil/core 2.8.0 → 2.10.0

package/cli/index.cjs

@@ -1,5 +1,5 @@
 /*!
- Stencil CLI (CommonJS) v2.8.0 | MIT Licensed | https://stenciljs.com
+ Stencil CLI (CommonJS) v2.10.0 | MIT Licensed | https://stenciljs.com
  */
 'use strict';
 
@@ -485,7 +485,7 @@ const getNpmConfigEnvArgs = (sys) => {
 const dependencies = [
 	{
 		name: "@stencil/core",
-		version: "2.8.0",
+		version: "2.10.0",
 		main: "compiler/stencil.js",
 		resources: [
 			"package.json",
@@ -533,6 +533,11 @@ const dependencies = [
 			"compiler/lib.es2020.sharedmemory.d.ts",
 			"compiler/lib.es2020.string.d.ts",
 			"compiler/lib.es2020.symbol.wellknown.d.ts",
+			"compiler/lib.es2021.d.ts",
+			"compiler/lib.es2021.full.d.ts",
+			"compiler/lib.es2021.promise.d.ts",
+			"compiler/lib.es2021.string.d.ts",
+			"compiler/lib.es2021.weakref.d.ts",
 			"compiler/lib.es5.d.ts",
 			"compiler/lib.es6.d.ts",
 			"compiler/lib.esnext.d.ts",
@@ -582,7 +587,7 @@ const dependencies = [
 	},
 	{
 		name: "typescript",
-		version: "4.2.3",
+		version: "4.3.5",
 		main: "lib/typescript.js"
 	}
 ];
@@ -795,82 +800,6 @@ const taskWatch = async (coreCompiler, config) => {
     }
 };
 
-class StencilCLIConfig {
-    constructor(options) {
-        this._args = (options === null || options === void 0 ? void 0 : options.args) || [];
-        this._logger = options === null || options === void 0 ? void 0 : options.logger;
-        this._sys = options === null || options === void 0 ? void 0 : options.sys;
-        this._flags = (options === null || options === void 0 ? void 0 : options.flags) || undefined;
-        this._validatedConfig = (options === null || options === void 0 ? void 0 : options.validatedConfig) || undefined;
-    }
-    static getInstance(options) {
-        if (!StencilCLIConfig.instance) {
-            StencilCLIConfig.instance = new StencilCLIConfig(options);
-        }
-        return StencilCLIConfig.instance;
-    }
-    resetInstance() {
-        delete StencilCLIConfig.instance;
-    }
-    get logger() {
-        return this._logger;
-    }
-    set logger(logger) {
-        this._logger = logger;
-    }
-    get sys() {
-        return this._sys;
-    }
-    set sys(sys) {
-        this._sys = sys;
-    }
-    get args() {
-        return this._args;
-    }
-    set args(args) {
-        this._args = args;
-    }
-    get task() {
-        return this._task;
-    }
-    set task(task) {
-        this._task = task;
-    }
-    get flags() {
-        return this._flags;
-    }
-    set flags(flags) {
-        this._flags = flags;
-    }
-    get coreCompiler() {
-        return this._coreCompiler;
-    }
-    set coreCompiler(coreCompiler) {
-        this._coreCompiler = coreCompiler;
-    }
-    get validatedConfig() {
-        return this._validatedConfig;
-    }
-    set validatedConfig(validatedConfig) {
-        this._validatedConfig = validatedConfig;
-    }
-}
-function initializeStencilCLIConfig(options) {
-    return StencilCLIConfig.getInstance(options);
-}
-function getStencilCLIConfig() {
-    return StencilCLIConfig.getInstance();
-}
-function getCompilerSystem() {
-    return getStencilCLIConfig().sys;
-}
-function getLogger() {
-    return getStencilCLIConfig().logger;
-}
-function getCoreCompiler() {
-    return getStencilCLIConfig().coreCompiler;
-}
-
 const tryFn = async (fn, ...args) => {
     try {
         return await fn(...args);
@@ -880,12 +809,12 @@ const tryFn = async (fn, ...args) => {
     }
     return null;
 };
-const isInteractive = (object) => {
-    var _a, _b;
+const isInteractive = (sys, config, object) => {
+    var _a;
     const terminalInfo = object ||
         Object.freeze({
-            tty: getCompilerSystem().isTTY() ? true : false,
-            ci: ['CI', 'BUILD_ID', 'BUILD_NUMBER', 'BITBUCKET_COMMIT', 'CODEBUILD_BUILD_ARN'].filter((v) => !!getCompilerSystem().getEnvironmentVar(v)).length > 0 || !!((_b = (_a = getStencilCLIConfig()) === null || _a === void 0 ? void 0 : _a.flags) === null || _b === void 0 ? void 0 : _b.ci),
+            tty: sys.isTTY() ? true : false,
+            ci: ['CI', 'BUILD_ID', 'BUILD_NUMBER', 'BITBUCKET_COMMIT', 'CODEBUILD_BUILD_ARN'].filter((v) => !!sys.getEnvironmentVar(v)).length > 0 || !!((_a = config.flags) === null || _a === void 0 ? void 0 : _a.ci),
         });
     return terminalInfo.tty && !terminalInfo.ci;
 };
@@ -900,93 +829,134 @@ function uuidv4() {
 }
 /**
  * Reads and parses a JSON file from the given `path`
+ * @param sys The system where the command is invoked
  * @param path the path on the file system to read and parse
  * @returns the parsed JSON
  */
-async function readJson(path) {
-    const file = await getCompilerSystem().readFile(path);
+async function readJson(sys, path) {
+    const file = await sys.readFile(path);
     return !!file && JSON.parse(file);
 }
-function hasDebug() {
-    return getStencilCLIConfig().flags.debug;
+/**
+ * Does the command have the debug flag?
+ * @param config The config passed into the Stencil command
+ * @returns true if --debug has been passed, otherwise false
+ */
+function hasDebug(config) {
+    return config.flags.debug;
 }
-function hasVerbose() {
-    return getStencilCLIConfig().flags.verbose && hasDebug();
+/**
+ * Does the command have the verbose and debug flags?
+ * @param config The config passed into the Stencil command
+ * @returns true if both --debug and --verbose have been passed, otherwise false
+ */
+function hasVerbose(config) {
+    return config.flags.verbose && hasDebug(config);
 }
 
 /**
  * Used to determine if tracking should occur.
+ * @param config The config passed into the Stencil command
+ * @param sys The system where the command is invoked
  * @param ci whether or not the process is running in a Continuous Integration (CI) environment
  * @returns true if telemetry should be sent, false otherwise
  */
-async function shouldTrack(ci) {
-    return !ci && isInteractive() && (await checkTelemetry());
+async function shouldTrack(config, sys, ci) {
+    return !ci && isInteractive(sys, config) && (await checkTelemetry(sys));
 }
 
 const isTest$1 = () => process.env.JEST_WORKER_ID !== undefined;
-const defaultConfig = () => getCompilerSystem().resolvePath(`${getCompilerSystem().homeDir()}/.ionic/${isTest$1() ? 'tmp-config.json' : 'config.json'}`);
-const defaultConfigDirectory = () => getCompilerSystem().resolvePath(`${getCompilerSystem().homeDir()}/.ionic`);
+const defaultConfig = (sys) => sys.resolvePath(`${sys.homeDir()}/.ionic/${isTest$1() ? 'tmp-config.json' : 'config.json'}`);
+const defaultConfigDirectory = (sys) => sys.resolvePath(`${sys.homeDir()}/.ionic`);
 /**
- * Reads an Ionic configuration file from disk, parses it, and performs any necessary corrections to it if ceratin
+ * Reads an Ionic 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
  */
-async function readConfig() {
-    let config = await readJson(defaultConfig());
+async function readConfig(sys) {
+    let config = await readJson(sys, defaultConfig(sys));
     if (!config) {
         config = {
             'tokens.telemetry': uuidv4(),
             'telemetry.stencil': true,
         };
-        await writeConfig(config);
+        await writeConfig(sys, config);
     }
     else if (!UUID_REGEX.test(config['tokens.telemetry'])) {
         const newUuid = uuidv4();
-        await writeConfig({ ...config, 'tokens.telemetry': newUuid });
+        await writeConfig(sys, { ...config, 'tokens.telemetry': newUuid });
         config['tokens.telemetry'] = newUuid;
     }
     return config;
 }
-async function writeConfig(config) {
+/**
+ * Writes an Ionic configuration file to disk.
+ * @param sys The system where the command is invoked
+ * @param config The config passed into the Stencil command
+ * @returns boolean If the command was successful
+ */
+async function writeConfig(sys, config) {
     let result = false;
     try {
-        await getCompilerSystem().createDir(defaultConfigDirectory(), { recursive: true });
-        await getCompilerSystem().writeFile(defaultConfig(), JSON.stringify(config, null, 2));
+        await sys.createDir(defaultConfigDirectory(sys), { recursive: true });
+        await sys.writeFile(defaultConfig(sys), JSON.stringify(config, null, 2));
         result = true;
     }
     catch (error) {
-        console.error(`Stencil Telemetry: couldn't write configuration file to ${defaultConfig()} - ${error}.`);
+        console.error(`Stencil Telemetry: couldn't write configuration file to ${defaultConfig(sys)} - ${error}.`);
     }
     return result;
 }
-async function updateConfig(newOptions) {
-    const config = await readConfig();
-    return await writeConfig(Object.assign(config, newOptions));
+/**
+ * Update a subset of the Ionic config.
+ * @param sys The system where the command is invoked
+ * @param newOptions The new options to save
+ * @returns boolean If the command was successful
+ */
+async function updateConfig(sys, newOptions) {
+    const config = await readConfig(sys);
+    return await writeConfig(sys, Object.assign(config, newOptions));
 }
 
+const isOutputTargetDocs = (o) => o.type === DOCS_README || o.type === DOCS_JSON || o.type === DOCS_CUSTOM || o.type === DOCS_VSCODE;
+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 within taskBuild to provide the component_count property.
+ *
+ * @param sys The system where the command is invoked
+ * @param config The config passed into the Stencil command
+ * @param logger The tool used to do logging
+ * @param coreCompiler The compiler used to do builds
  * @param result The results of a compiler build.
  */
-async function telemetryBuildFinishedAction(result) {
-    const { flags, logger } = getStencilCLIConfig();
-    const tracking = await shouldTrack(flags.ci);
+async function telemetryBuildFinishedAction(sys, config, logger, coreCompiler, result) {
+    const tracking = await shouldTrack(config, sys, config.flags.ci);
     if (!tracking) {
         return;
     }
     const component_count = Object.keys(result.componentGraph).length;
-    const data = await prepareData(result.duration, component_count);
-    await sendMetric('stencil_cli_command', data);
+    const data = await prepareData(coreCompiler, config, sys, result.duration, component_count);
+    await sendMetric(sys, config, 'stencil_cli_command', data);
     logger.debug(`${logger.blue('Telemetry')}: ${logger.gray(JSON.stringify(data))}`);
 }
 /**
  * A function to wrap a compiler task function around. Will send telemetry if, and only if, the machine allows.
+ * @param sys The system where the command is invoked
+ * @param config The config passed into the Stencil command
+ * @param logger The tool used to do logging
+ * @param coreCompiler The compiler used to do builds
  * @param action A Promise-based function to call in order to get the duration of any given command.
  * @returns void
  */
-async function telemetryAction(action) {
-    const { flags, logger } = getStencilCLIConfig();
-    const tracking = await shouldTrack(!!flags.ci);
+async function telemetryAction(sys, config, logger, coreCompiler, action) {
+    var _a;
+    const tracking = await shouldTrack(config, sys, !!((_a = config === null || config === void 0 ? void 0 : config.flags) === null || _a === void 0 ? void 0 : _a.ci));
     let duration = undefined;
     let error;
     if (action) {
@@ -1001,51 +971,51 @@ async function telemetryAction(action) {
         duration = end.getTime() - start.getTime();
     }
     // We'll get componentCount details inside the taskBuild, so let's not send two messages.
-    if (!tracking || (flags.task == 'build' && !flags.args.includes('--watch'))) {
+    if (!tracking || (config.flags.task == 'build' && !config.flags.args.includes('--watch'))) {
         return;
     }
-    const data = await prepareData(duration);
-    await sendMetric('stencil_cli_command', data);
+    const data = await prepareData(coreCompiler, config, sys, duration);
+    await sendMetric(sys, config, 'stencil_cli_command', data);
     logger.debug(`${logger.blue('Telemetry')}: ${logger.gray(JSON.stringify(data))}`);
     if (error) {
         throw error;
     }
 }
-function hasAppTarget() {
-    return getStencilCLIConfig().validatedConfig.config.outputTargets.some((target) => target.type === 'www' && (!!target.serviceWorker || (!!target.baseUrl && target.baseUrl !== '/')));
+function hasAppTarget(config) {
+    return config.outputTargets.some((target) => target.type === WWW && (!!target.serviceWorker || (!!target.baseUrl && target.baseUrl !== '/')));
 }
-function isUsingYarn() {
+function isUsingYarn(sys) {
     var _a;
-    return ((_a = getCompilerSystem().getEnvironmentVar('npm_execpath')) === null || _a === void 0 ? void 0 : _a.includes('yarn')) || false;
+    return ((_a = sys.getEnvironmentVar('npm_execpath')) === null || _a === void 0 ? void 0 : _a.includes('yarn')) || false;
 }
-async function getActiveTargets() {
-    const result = getStencilCLIConfig().validatedConfig.config.outputTargets.map((t) => t.type);
+async function getActiveTargets(config) {
+    const result = config.outputTargets.map((t) => t.type);
     return Array.from(new Set(result));
 }
-const prepareData = async (duration_ms, component_count = undefined) => {
-    var _a, _b, _c;
-    const { flags, sys } = getStencilCLIConfig();
-    const { typescript, rollup } = ((_a = getCoreCompiler()) === null || _a === void 0 ? void 0 : _a.versions) || { typescript: 'unknown', rollup: 'unknown' };
-    const packages = await getInstalledPackages();
-    const targets = await getActiveTargets();
-    const yarn = isUsingYarn();
-    const stencil = ((_b = getCoreCompiler()) === null || _b === void 0 ? void 0 : _b.version) || 'unknown';
+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 yarn = isUsingYarn(sys);
+    const stencil = coreCompiler.version || 'unknown';
     const system = `${sys.name} ${sys.version}`;
     const os_name = sys.details.platform;
     const os_version = sys.details.release;
     const cpu_model = sys.details.cpuModel;
-    const build = ((_c = getCoreCompiler()) === null || _c === void 0 ? void 0 : _c.buildId) || 'unknown';
-    const has_app_pwa_config = hasAppTarget();
+    const build = coreCompiler.buildId || 'unknown';
+    const has_app_pwa_config = hasAppTarget(config);
     return {
         yarn,
         duration_ms,
         component_count,
         targets,
         packages,
-        arguments: flags.args,
-        task: flags.task,
+        packages_no_versions: packagesNoVersions,
+        arguments: config.flags.args,
+        task: config.flags.task,
         stencil,
         system,
+        system_major: getMajorVersion(system),
         os_name,
         os_version,
         cpu_model,
@@ -1056,41 +1026,92 @@ const prepareData = async (duration_ms, component_count = undefined) => {
     };
 };
 /**
- * Reads package-lock.json and package.json files in order to cross references the dependencies and devDependencies properties. Pull the current installed version of each package under the @stencil, @ionic, and @capacitor scopes.
+ * 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 @stencil, @ionic, and @capacitor scopes.
  * @returns string[]
  */
-async function getInstalledPackages() {
+async function getInstalledPackages(sys, config) {
+    let packages = [];
+    let packagesNoVersions = [];
+    const yarn = isUsingYarn(sys);
     try {
         // Read package.json and package-lock.json
-        const appRootDir = getCompilerSystem().getCurrentDirectory();
-        const packageJson = await tryFn(readJson, getCompilerSystem().resolvePath(appRootDir + '/package.json'));
-        const packageLockJson = await tryFn(readJson, getCompilerSystem().resolvePath(appRootDir + '/package-lock.json'));
+        const appRootDir = sys.getCurrentDirectory();
+        const packageJson = await tryFn(readJson, sys, sys.resolvePath(appRootDir + '/package.json'));
         // They don't have a package.json for some reason? Eject button.
         if (!packageJson) {
-            return [];
+            return { packages, packagesNoVersions };
         }
-        const packages = Object.entries({
+        const rawPackages = Object.entries({
             ...packageJson.devDependencies,
             ...packageJson.dependencies,
         });
         // Collect packages only in the stencil, ionic, or capacitor org's:
         // https://www.npmjs.com/org/stencil
-        const ionicPackages = packages.filter(([k]) => k.startsWith('@stencil/') || k.startsWith('@ionic/') || k.startsWith('@capacitor/'));
-        const versions = packageLockJson
-            ? ionicPackages.map(([k, v]) => { var _a, _b, _c, _d; return `${k}@${(_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}`; })
-            : ionicPackages.map(([k, v]) => `${k}@${v}`);
-        return versions;
+        const ionicPackages = rawPackages.filter(([k]) => k.startsWith('@stencil/') || k.startsWith('@ionic/') || k.startsWith('@capacitor/'));
+        try {
+            packages = yarn ? await yarnPackages(sys, ionicPackages) : await npmPackages(sys, ionicPackages);
+        }
+        catch (e) {
+            packages = ionicPackages.map(([k, v]) => `${k}@${v.replace('^', '')}`);
+        }
+        packagesNoVersions = ionicPackages.map(([k]) => `${k}`);
+        return { packages, packagesNoVersions };
     }
     catch (err) {
-        hasDebug() && console.error(err);
-        return [];
+        hasDebug(config) && console.error(err);
+        return { packages, packagesNoVersions };
     }
 }
+/**
+ * Visits the npm lock file to find the exact versions that are installed
+ * @param sys The system where the command is invoked
+ * @param ionicPackages a list of the found packages matching `@stencil`, `@capacitor`, or `@ionic` from the package.json file.
+ * @returns an array of strings of all the packages and their versions.
+ */
+async function npmPackages(sys, ionicPackages) {
+    const appRootDir = sys.getCurrentDirectory();
+    const packageLockJson = await tryFn(readJson, sys, sys.resolvePath(appRootDir + '/package-lock.json'));
+    return ionicPackages.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;
+        return `${k}@${version}`;
+    });
+}
+/**
+ * Visits the yarn lock file to find the exact versions that are installed
+ * @param sys The system where the command is invoked
+ * @param ionicPackages a list of the found packages matching `@stencil`, `@capacitor`, or `@ionic` from the package.json file.
+ * @returns an array of strings of all the packages and their versions.
+ */
+async function yarnPackages(sys, ionicPackages) {
+    const appRootDir = sys.getCurrentDirectory();
+    const yarnLock = sys.readFileSync(sys.resolvePath(appRootDir + '/yarn.lock'));
+    const yarnLockYml = sys.parseYarnLockFile(yarnLock);
+    return ionicPackages.map(([k, v]) => {
+        var _a;
+        const identifiedVersion = `${k}@${v}`;
+        let version = (_a = yarnLockYml.object[identifiedVersion]) === null || _a === void 0 ? void 0 : _a.version;
+        version = version.includes('undefined') ? sanitizeDeclaredVersion(identifiedVersion) : version;
+        return `${k}@${version}`;
+    });
+}
+/**
+ * This function is used for fallback purposes, where an npm or yarn lock file doesn't exist in the consumers directory.
+ * This will strip away '*', '^' and '~' from the declared package versions in a package.json.
+ * @param version the raw semver pattern identifier version string
+ * @returns a cleaned up representation without any qualifiers
+ */
+function sanitizeDeclaredVersion(version) {
+    return version.replace(/[*^~]/g, '');
+}
 /**
  * If telemetry is enabled, send a metric via IPC to a forked process for uploading.
  */
-async function sendMetric(name, value) {
-    const session_id = await getTelemetryToken();
+async function sendMetric(sys, config, name, value) {
+    const session_id = await getTelemetryToken(sys);
     const message = {
         name,
         timestamp: new Date().toISOString(),
@@ -1098,25 +1119,28 @@ async function sendMetric(name, value) {
         value,
         session_id,
     };
-    await sendTelemetry({ type: 'telemetry', message });
+    await sendTelemetry(sys, config, { type: 'telemetry', message });
 }
 /**
  * Used to read the config file's tokens.telemetry property.
+ * @param sys The system where the command is invoked
  * @returns string
  */
-async function getTelemetryToken() {
-    const config = await readConfig();
+async function getTelemetryToken(sys) {
+    const config = await readConfig(sys);
     if (config['tokens.telemetry'] === undefined) {
         config['tokens.telemetry'] = uuidv4();
-        await writeConfig(config);
+        await writeConfig(sys, config);
     }
     return config['tokens.telemetry'];
 }
 /**
  * Issues a request to the telemetry server.
+ * @param sys The system where the command is invoked
+ * @param config The config passed into the Stencil command
  * @param data Data to be tracked
  */
-async function sendTelemetry(data) {
+async function sendTelemetry(sys, config, data) {
     try {
         const now = new Date().toISOString();
         const body = {
@@ -1124,52 +1148,64 @@ async function sendTelemetry(data) {
             sent_at: now,
         };
         // This request is only made if telemetry is on.
-        const response = await getCompilerSystem().fetch('https://api.ionicjs.com/events/metrics', {
+        const response = await sys.fetch('https://api.ionicjs.com/events/metrics', {
             method: 'POST',
             headers: {
                 'Content-Type': 'application/json',
             },
             body: JSON.stringify(body),
         });
-        hasVerbose() &&
+        hasVerbose(config) &&
             console.debug('\nSent %O metric to events service (status: %O)', data.message.name, response.status, '\n');
         if (response.status !== 204) {
-            hasVerbose() &&
+            hasVerbose(config) &&
                 console.debug('\nBad response from events service. Request body: %O', response.body.toString(), '\n');
         }
     }
     catch (e) {
-        hasVerbose() && console.debug('Telemetry request failed:', e);
+        hasVerbose(config) && console.debug('Telemetry request failed:', e);
     }
 }
 /**
  * Checks if telemetry is enabled on this machine
+ * @param sys The system where the command is invoked
  * @returns true if telemetry is enabled, false otherwise
  */
-async function checkTelemetry() {
-    const config = await readConfig();
+async function checkTelemetry(sys) {
+    const config = await readConfig(sys);
     if (config['telemetry.stencil'] === undefined) {
         config['telemetry.stencil'] = true;
-        await writeConfig(config);
+        await writeConfig(sys, config);
     }
     return config['telemetry.stencil'];
 }
 /**
  * Writes to the config file, enabling telemetry for this machine.
+ * @param sys The system where the command is invoked
  * @returns true if writing the file was successful, false otherwise
  */
-async function enableTelemetry() {
-    return await updateConfig({ 'telemetry.stencil': true });
+async function enableTelemetry(sys) {
+    return await updateConfig(sys, { 'telemetry.stencil': true });
 }
 /**
  * Writes to the config file, disabling telemetry for this machine.
+ * @param sys The system where the command is invoked
  * @returns true if writing the file was successful, false otherwise
  */
-async function disableTelemetry() {
-    return await updateConfig({ 'telemetry.stencil': false });
+async function disableTelemetry(sys) {
+    return await updateConfig(sys, { 'telemetry.stencil': false });
+}
+/**
+ * Takes in a semver string in order to return the major version.
+ * @param version The fully qualified semver version
+ * @returns a string of the major version
+ */
+function getMajorVersion(version) {
+    const parts = version.split('.');
+    return parts[0];
 }
 
-const taskBuild = async (coreCompiler, config) => {
+const taskBuild = async (coreCompiler, config, sys) => {
     if (config.flags.watch) {
         // watch build
         await taskWatch(coreCompiler, config);
@@ -1182,7 +1218,10 @@ const taskBuild = async (coreCompiler, config) => {
         const versionChecker = startCheckVersion(config, coreCompiler.version);
         const compiler = await coreCompiler.createCompiler(config);
         const results = await compiler.build();
-        await telemetryBuildFinishedAction(results);
+        // TODO(STENCIL-148) make this parameter no longer optional, remove the surrounding if statement
+        if (sys) {
+            await telemetryBuildFinishedAction(sys, config, config.logger, coreCompiler, results);
+        }
         await compiler.destroy();
         if (results.hasError) {
             exitCode = 1;
@@ -1205,12 +1244,6 @@ const taskBuild = async (coreCompiler, config) => {
     }
 };
 
-const isOutputTargetDocs = (o) => o.type === DOCS_README || o.type === DOCS_JSON || o.type === DOCS_CUSTOM || o.type === DOCS_VSCODE;
-const DOCS_CUSTOM = 'docs-custom';
-const DOCS_JSON = `docs-json`;
-const DOCS_README = `docs-readme`;
-const DOCS_VSCODE = `docs-vscode`;
-
 const taskDocs = async (coreCompiler, config) => {
     config.devServer = null;
     config.outputTargets = config.outputTargets.filter(isOutputTargetDocs);
@@ -1221,9 +1254,7 @@ const taskDocs = async (coreCompiler, config) => {
     await compiler.destroy();
 };
 
-const IS_DENO_ENV = typeof Deno !== 'undefined';
-const IS_NODE_ENV = !IS_DENO_ENV &&
-    typeof global !== 'undefined' &&
+const IS_NODE_ENV = typeof global !== 'undefined' &&
     typeof require === 'function' &&
     !!global.process &&
     typeof __filename === 'string' &&
@@ -1395,25 +1426,24 @@ describe('${name}', () => {
  */
 const toPascalCase = (str) => str.split('-').reduce((res, part) => res + part[0].toUpperCase() + part.substr(1), '');
 
-const taskTelemetry = async () => {
-    const logger = getLogger();
-    const prompt = logger.dim(getCompilerSystem().details.platform === 'windows' ? '>' : '$');
-    const isEnabling = getStencilCLIConfig().flags.args.includes('on');
-    const isDisabling = getStencilCLIConfig().flags.args.includes('off');
+const taskTelemetry = async (config, sys, logger) => {
+    const prompt = logger.dim(sys.details.platform === 'windows' ? '>' : '$');
+    const isEnabling = config.flags.args.includes('on');
+    const isDisabling = config.flags.args.includes('off');
     const INFORMATION = `Opt in or our of telemetry. Information about the data we collect is available on our website: ${logger.bold('https://stenciljs.com/telemetry')}`;
     const THANK_YOU = `Thank you for helping to make Stencil better! 💖`;
     const ENABLED_MESSAGE = `${logger.green('Enabled')}. ${THANK_YOU}\n\n`;
     const DISABLED_MESSAGE = `${logger.red('Disabled')}\n\n`;
-    const hasTelemetry = await checkTelemetry();
+    const hasTelemetry = await checkTelemetry(sys);
     if (isEnabling) {
-        const result = await enableTelemetry();
+        const result = await enableTelemetry(sys);
         result
             ? console.log(`\n  ${logger.bold('Telemetry is now ') + ENABLED_MESSAGE}`)
             : console.log(`Something went wrong when enabling Telemetry.`);
         return;
     }
     if (isDisabling) {
-        const result = await disableTelemetry();
+        const result = await disableTelemetry(sys);
         result
             ? console.log(`\n  ${logger.bold('Telemetry is now ') + DISABLED_MESSAGE}`)
             : console.log(`Something went wrong when disabling Telemetry.`);
@@ -1428,9 +1458,7 @@ const taskTelemetry = async () => {
   `);
 };
 
-const taskHelp = async () => {
-    const logger = getLogger();
-    const sys = getCompilerSystem();
+const taskHelp = async (config, logger, sys) => {
     const prompt = logger.dim(sys.details.platform === 'windows' ? '>' : '$');
     console.log(`
   ${logger.bold('Build:')} ${logger.dim('Build components for development or production.')}
@@ -1461,11 +1489,13 @@ const taskHelp = async () => {
     ${prompt} ${logger.green('stencil generate')} or ${logger.green('stencil g')}
 
 `);
-    await taskTelemetry();
+    // TODO(STENCIL-148) make this parameter no longer optional, remove the surrounding if statement
+    if (sys) {
+        await taskTelemetry(config, sys, logger);
+    }
     console.log(`
   ${logger.bold('Examples:')}
 
-  
   ${prompt} ${logger.green('stencil build --dev --watch --serve')}
   ${prompt} ${logger.green('stencil build --prerender')}
   ${prompt} ${logger.green('stencil test --spec --e2e')}
@@ -1566,8 +1596,6 @@ const taskTest = async (config) => {
 
 const run = async (init) => {
     const { args, logger, sys } = init;
-    // Initialize the singleton so we can use this throughout the lifecycle of the CLI.
-    const stencilCLIConfig = initializeStencilCLIConfig({ args, logger, sys });
     try {
         const flags = parseFlags(args, sys);
         const task = flags.task;
@@ -1580,13 +1608,8 @@ const run = async (init) => {
         if (isFunction(sys.applyGlobalPatch)) {
             sys.applyGlobalPatch(sys.getCurrentDirectory());
         }
-        // Update singleton with modifications
-        stencilCLIConfig.logger = logger;
-        stencilCLIConfig.task = task;
-        stencilCLIConfig.sys = sys;
-        stencilCLIConfig.flags = flags;
         if (task === 'help' || flags.help) {
-            taskHelp();
+            await taskHelp({ flags: { task: 'help', args }, outputTargets: [] }, logger, sys);
             return;
         }
         startupLog(logger, task);
@@ -1605,7 +1628,6 @@ const run = async (init) => {
             return sys.exit(1);
         }
         const coreCompiler = await loadCoreCompiler(sys);
-        stencilCLIConfig.coreCompiler = coreCompiler;
         if (task === 'version' || flags.version) {
             console.log(coreCompiler.version);
             return;
@@ -1613,7 +1635,7 @@ const run = async (init) => {
         startupLogVersion(logger, task, coreCompiler);
         loadedCompilerLog(sys, logger, flags, coreCompiler);
         if (task === 'info') {
-            await telemetryAction(async () => {
+            await telemetryAction(sys, { flags: { task: 'info' }, outputTargets: [] }, logger, coreCompiler, async () => {
                 await taskInfo(coreCompiler, sys, logger);
             });
             return;
@@ -1632,13 +1654,12 @@ const run = async (init) => {
                 return sys.exit(1);
             }
         }
-        stencilCLIConfig.validatedConfig = validated;
         if (isFunction(sys.applyGlobalPatch)) {
             sys.applyGlobalPatch(validated.config.rootDir);
         }
         await sys.ensureResources({ rootDir: validated.config.rootDir, logger, dependencies: dependencies });
-        await telemetryAction(async () => {
-            await runTask(coreCompiler, validated.config, task);
+        await telemetryAction(sys, validated.config, logger, coreCompiler, async () => {
+            await runTask(coreCompiler, validated.config, task, sys);
         });
     }
     catch (e) {
@@ -1648,12 +1669,12 @@ const run = async (init) => {
         }
     }
 };
-const runTask = async (coreCompiler, config, task) => {
-    config.flags = config.flags || {};
+const runTask = async (coreCompiler, config, task, sys) => {
+    config.flags = config.flags || { task };
     config.outputTargets = config.outputTargets || [];
     switch (task) {
         case 'build':
-            await taskBuild(coreCompiler, config);
+            await taskBuild(coreCompiler, config, sys);
             break;
         case 'docs':
             await taskDocs(coreCompiler, config);
@@ -1663,7 +1684,7 @@ const runTask = async (coreCompiler, config, task) => {
             await taskGenerate(coreCompiler, config);
             break;
         case 'help':
-            taskHelp();
+            taskHelp(config, config.logger, sys);
             break;
         case 'prerender':
             await taskPrerender(coreCompiler, config);
@@ -1672,7 +1693,10 @@ const runTask = async (coreCompiler, config, task) => {
             await taskServe(config);
             break;
         case 'telemetry':
-            await taskTelemetry();
+            // TODO(STENCIL-148) make this parameter no longer optional, remove the surrounding if statement
+            if (sys) {
+                await taskTelemetry(config, sys, config.logger);
+            }
             break;
         case 'test':
             await taskTest(config);
@@ -1682,7 +1706,7 @@ const runTask = async (coreCompiler, config, task) => {
             break;
         default:
             config.logger.error(`${config.logger.emoji('❌ ')}Invalid stencil command, please see the options below:`);
-            taskHelp();
+            taskHelp(config, config.logger, sys);
             return config.sys.exit(1);
     }
 };
@@ -1690,3 +1714,4 @@ const runTask = async (coreCompiler, config, task) => {
 exports.parseFlags = parseFlags;
 exports.run = run;
 exports.runTask = runTask;
+//# sourceMappingURL=index.cjs.map