Merge branch 'main' into feat/add-type-parameters-to-class-name

Author: deleonio

src/cli/run.ts

@@ -113,18 +113,27 @@ export const run = async (init: d.CliInitOptions) => {
   }
 };
 
+/**
+ * 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
+ */
 export const runTask = async (
   coreCompiler: CoreCompiler,
   config: d.Config,
   task: d.TaskCommand,
   sys?: d.CompilerSystem
-) => {
+): Promise<void> => {
   const logger = config.logger ?? createLogger();
   const strictConfig: ValidatedConfig = {
     ...config,
     flags: createConfigFlags(config.flags ?? { task }),
     logger,
     outputTargets: config.outputTargets ?? [],
+    sys: sys ?? coreCompiler.createSystem({ logger }),
   };
 
   switch (task) {

src/cli/telemetry/test/telemetry.spec.ts

@@ -2,7 +2,7 @@ import type * as d from '../../../declarations';
 import * as telemetry from '../telemetry';
 import * as shouldTrack from '../shouldTrack';
 import { createSystem } from '../../../compiler/sys/stencil-sys';
-import { mockLogger, mockValidatedConfig } from '@stencil/core/testing';
+import { mockValidatedConfig } from '@stencil/core/testing';
 import * as coreCompiler from '@stencil/core/compiler';
 import { anonymizeConfigForTelemetry } from '../telemetry';
 import { DIST, DIST_CUSTOM_ELEMENTS, DIST_HYDRATE_SCRIPT, WWW } from '../../../compiler/output-targets/output-utils';
@@ -148,25 +148,21 @@ describe('prepareData', () => {
   let sys: d.CompilerSystem;
 
   beforeEach(() => {
-    config = {
-      outputTargets: [],
-      flags: createConfigFlags(),
-      logger: mockLogger(),
-    };
-
-    sys = createSystem();
+    config = mockValidatedConfig();
+    sys = config.sys;
+    // set static name + versions, otherwise tests will pull in the dev build's data (which changes per build)
+    sys.name = 'in-memory';
+    sys.version = '__VERSION:STENCIL__';
   });
 
-  it('provides an object', async () => {
+  it('prepares an object to send to ionic', async () => {
     const data = await telemetry.prepareData(coreCompiler, config, sys, 1000);
     expect(data).toEqual({
       arguments: [],
       build: coreCompiler.buildId,
       component_count: undefined,
-      config: {
-        flags: createConfigFlags(),
-        outputTargets: [],
-      },
+      // the configuration generation is tested elsewhere, just verify we're sending something under this flag
+      config: expect.any(Object),
       cpu_model: '',
       duration_ms: 1000,
       has_app_pwa_config: false,
@@ -185,101 +181,39 @@ describe('prepareData', () => {
     });
   });
 
-  it('updates when there is a PWA config', async () => {
-    const config: d.ValidatedConfig = {
-      flags: createConfigFlags(),
-      logger: mockLogger(),
-      outputTargets: [{ type: 'www', baseUrl: 'https://example.com', serviceWorker: { swDest: './tmp' } }],
-    };
+  describe('has_app_pwa_config property', () => {
+    it('sets `has_app_pwa_config` to true when there is a service worker', async () => {
+      const config = mockValidatedConfig({
+        outputTargets: [{ type: 'www', baseUrl: 'https://example.com' }],
+      });
 
-    const data = await telemetry.prepareData(coreCompiler, config, sys, 1000);
+      const data = await telemetry.prepareData(coreCompiler, config, sys, 1000);
 
-    expect(data).toEqual({
-      arguments: [],
-      build: coreCompiler.buildId,
-      component_count: undefined,
-      config: {
-        flags: {
-          args: [],
-          knownArgs: [],
-          task: null,
-          unknownArgs: [],
-        },
-        outputTargets: [
-          {
-            baseUrl: 'omitted',
-            serviceWorker: {
-              swDest: 'omitted',
-            },
-            type: 'www',
-          },
-        ],
-      },
-      cpu_model: '',
-      duration_ms: 1000,
-      has_app_pwa_config: true,
-      os_name: '',
-      os_version: '',
-      packages: [],
-      packages_no_versions: [],
-      rollup: coreCompiler.versions.rollup,
-      stencil: coreCompiler.versions.stencil,
-      system: 'in-memory __VERSION:STENCIL__',
-      system_major: 'in-memory __VERSION:STENCIL__',
-      targets: ['www'],
-      task: null,
-      typescript: coreCompiler.versions.typescript,
-      yarn: false,
+      expect(data.has_app_pwa_config).toBe(true);
     });
-  });
 
-  it('updates when there is a component count passed in', async () => {
-    const config: d.ValidatedConfig = {
-      flags: createConfigFlags(),
-      logger: mockLogger(),
-      outputTargets: [{ type: 'www', baseUrl: 'https://example.com', serviceWorker: { swDest: './tmp' } }],
-    };
+    it("sets `has_app_pwa_config` to true for a non '/' baseUrl", async () => {
+      const config = mockValidatedConfig({
+        outputTargets: [{ type: 'www', serviceWorker: { swDest: './tmp' } }],
+      });
 
-    const data = await telemetry.prepareData(coreCompiler, config, sys, 1000, 12);
+      const data = await telemetry.prepareData(coreCompiler, config, sys, 1000);
 
-    expect(data).toEqual({
-      arguments: [],
-      build: coreCompiler.buildId,
-      component_count: 12,
-      config: {
-        flags: {
-          args: [],
-          knownArgs: [],
-          task: null,
-          unknownArgs: [],
-        },
-        outputTargets: [
-          {
-            baseUrl: 'omitted',
-            serviceWorker: {
-              swDest: 'omitted',
-            },
-            type: WWW,
-          },
-        ],
-      },
-      cpu_model: '',
-      duration_ms: 1000,
-      has_app_pwa_config: true,
-      os_name: '',
-      os_version: '',
-      packages: [],
-      packages_no_versions: [],
-      rollup: coreCompiler.versions.rollup,
-      stencil: coreCompiler.versions.stencil,
-      system: 'in-memory __VERSION:STENCIL__',
-      system_major: 'in-memory __VERSION:STENCIL__',
-      targets: ['www'],
-      task: null,
-      typescript: coreCompiler.versions.typescript,
-      yarn: false,
+      expect(data.has_app_pwa_config).toBe(true);
     });
   });
+
+  it('sends a component count when one is provided', async () => {
+    const COMPONENT_COUNT = 12;
+
+    const config = mockValidatedConfig({
+      outputTargets: [{ type: 'www' }],
+    });
+
+    const data = await telemetry.prepareData(coreCompiler, config, sys, 1000, COMPONENT_COUNT);
+
+    expect(data.component_count).toEqual(COMPONENT_COUNT);
+  });
 });
 
 describe('anonymizeConfigForTelemetry', () => {

src/compiler/compiler.ts

@@ -1,4 +1,4 @@
-import type { Compiler, Config, Diagnostic } from '../declarations';
+import type { Compiler, Config, Diagnostic, ValidatedConfig } from '../declarations';
 import { Cache } from './cache';
 import { CompilerContext } from './build/compiler-ctx';
 import { createFullBuild } from './build/full-build';
@@ -22,7 +22,7 @@ export const createCompiler = async (userConfig: Config): Promise<Compiler> => {
   // actual compiler code
   // could be in a web worker on the browser
   // or the main thread in node
-  const config = getConfig(userConfig);
+  const config: ValidatedConfig = getConfig(userConfig);
   const diagnostics: Diagnostic[] = [];
   const sys = config.sys;
   const compilerCtx = new CompilerContext();

src/compiler/config/load-config.ts

@@ -46,10 +46,14 @@ export const loadConfig = async (init: LoadConfigInit = {}): Promise<LoadConfigR
   const unknownConfig: UnvalidatedConfig = {};
 
   try {
-    const sys = init.sys || createSystem();
     const config = init.config || {};
     let configPath = init.configPath || config.configPath;
 
+    // Pull the {@link CompilerSystem} out of the initialization object, or create one if it does not exist.
+    // This entity is needed to load the project's configuration (and therefore needs to be created before it can be
+    // attached to a configuration entity, validated or otherwise)
+    const sys = init.sys ?? createSystem();
+
     const loadedConfigFile = await loadConfigFile(sys, results.diagnostics, configPath);
     if (hasError(results.diagnostics)) {
       return results;

src/compiler/config/validate-config.ts

@@ -12,6 +12,7 @@ import { validateRollupConfig } from './validate-rollup-config';
 import { validateTesting } from './validate-testing';
 import { validateWorkers } from './validate-workers';
 import { createLogger } from '../sys/logger/console-logger';
+import { createSystem } from '../sys/stencil-sys';
 
 /**
  * Represents the results of validating a previously unvalidated configuration
@@ -41,7 +42,7 @@ export const validateConfig = (
   userConfig: UnvalidatedConfig = {},
   bootstrapConfig: LoadConfigInit
 ): ConfigValidationResults => {
-  const config = Object.assign({}, userConfig || {}); // not positive it's json safe
+  const config = Object.assign({}, userConfig); // not positive it's json safe
   const diagnostics: Diagnostic[] = [];
 
   const logger = bootstrapConfig.logger || config.logger || createLogger();
@@ -52,6 +53,7 @@ export const validateConfig = (
     flags: JSON.parse(JSON.stringify(config.flags || {})),
     logger,
     outputTargets: config.outputTargets ?? [],
+    sys: config.sys ?? bootstrapConfig.sys ?? createSystem({ logger }),
   };
 
   // default devMode false

src/compiler/sys/config.ts

@@ -11,12 +11,9 @@ export const getConfig = (userConfig: d.Config): d.ValidatedConfig => {
     flags: createConfigFlags(userConfig.flags ?? {}),
     logger,
     outputTargets: userConfig.outputTargets ?? [],
+    sys: userConfig.sys ?? createSystem({ logger }),
   };
 
-  if (!config.sys) {
-    config.sys = createSystem({ logger: config.logger });
-  }
-
   setPlatformPath(config.sys.platformPath);
 
   if (config.flags.debug || config.flags.verbose) {

src/declarations/stencil-public-compiler.ts

@@ -409,7 +409,7 @@ type RequireFields<T, K extends keyof T> = T & { [P in K]-?: T[P] };
 /**
  * Fields in {@link Config} to make required for {@link ValidatedConfig}
  */
-type StrictConfigFields = 'flags' | 'logger' | 'outputTargets';
+type StrictConfigFields = 'flags' | 'logger' | 'outputTargets' | 'sys';
 
 /**
  * A version of {@link Config} that makes certain fields required. This type represents a valid configuration entity.

src/testing/mocks.ts

@@ -35,6 +35,7 @@ export function mockValidatedConfig(overrides: Partial<ValidatedConfig> = {}): V
     flags: createConfigFlags(),
     logger: mockLogger(),
     outputTargets: baseConfig.outputTargets ?? [],
+    sys: createTestingSystem(),
     ...overrides,
   };
 }