@atlaspack/core 2.16.2-canary.48 → 2.16.2-canary.481

package/src/{utils.js → utils.ts}

@@ -1,5 +1,3 @@
-// @flow strict-local
-
 import type {
   FilePath,
   FileCreateInvalidation,
@@ -20,6 +18,14 @@ import baseX from 'base-x';
 import {hashObject} from '@atlaspack/utils';
 import {fromProjectPath, toProjectPath} from './projectPath';
 
+// flow-to-ts helpers
+export type SetComplement<A, B extends A> = A extends B ? never : A;
+export type Diff<T extends U, U extends object> = Pick<
+  T,
+  SetComplement<keyof T, keyof U>
+>;
+// /flow-to-ts helpers
+
 const base62 = baseX(
   '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ',
 );
@@ -28,7 +34,7 @@ export function getBundleGroupId(bundleGroup: BundleGroup): string {
   return 'bundle_group:' + bundleGroup.target.name + bundleGroup.entryAssetId;
 }
 
-export function assertSignalNotAborted(signal: ?AbortSignal): void {
+export function assertSignalNotAborted(signal?: AbortSignal | null): void {
   if (signal && signal.aborted) {
     throw new BuildAbortError();
   }
@@ -40,7 +46,7 @@ export class BuildAbortError extends Error {
 
 export function getPublicId(
   id: string,
-  alreadyExists: (string) => boolean,
+  alreadyExists: (arg1: string) => boolean,
 ): string {
   let encoded = base62.encode(Buffer.from(id, 'hex'));
   for (let end = 5; end <= encoded.length; end++) {
@@ -74,7 +80,7 @@ const ignoreOptions = new Set([
 
 export function optionsProxy(
   options: AtlaspackOptions,
-  invalidateOnOptionChange: (string) => void,
+  invalidateOnOptionChange: (arg1: string) => void,
   addDevDependency?: (devDep: InternalDevDepOptions) => void,
 ): AtlaspackOptions {
   let packageManager = addDevDependency
@@ -85,7 +91,7 @@ export function optionsProxy(
       )
     : options.packageManager;
   return new Proxy(options, {
-    get(target, prop) {
+    get(target: AtlaspackOptions, prop: string) {
       if (prop === 'packageManager') {
         return packageManager;
       }
@@ -94,6 +100,7 @@ export function optionsProxy(
         invalidateOnOptionChange(prop);
       }
 
+      // @ts-expect-error TS7053
       return target[prop];
     },
   });
@@ -104,7 +111,7 @@ function proxyPackageManager(
   packageManager: PackageManager,
   addDevDependency: (devDep: InternalDevDepOptions) => void,
 ): PackageManager {
-  let require = (id: string, from: string, opts) => {
+  let require = (id: string, from: string, opts: any) => {
     addDevDependency({
       specifier: id,
       resolveFrom: toProjectPath(projectRoot, from),
@@ -114,19 +121,20 @@ function proxyPackageManager(
   };
 
   return new Proxy(packageManager, {
-    get(target, prop) {
+    get(target: PackageManager, prop: string) {
       if (prop === 'require') {
         return require;
       }
 
-      // $FlowFixMe
+      // @ts-expect-error TS7053
       return target[prop];
     },
   });
 }
 
-export function hashFromOption(value: mixed): string {
+export function hashFromOption(value: unknown): string {
   if (typeof value === 'object' && value != null) {
+    // @ts-expect-error TS2345
     return hashObject(value);
   }
 
@@ -137,18 +145,25 @@ export function invalidateOnFileCreateToInternal(
   projectRoot: FilePath,
   invalidation: FileCreateInvalidation,
 ): InternalFileCreateInvalidation {
+  // @ts-expect-error TS2339
   if (invalidation.glob != null) {
+    // @ts-expect-error TS2339
     return {glob: toProjectPath(projectRoot, invalidation.glob)};
+    // @ts-expect-error TS2339
   } else if (invalidation.filePath != null) {
     return {
+      // @ts-expect-error TS2339
       filePath: toProjectPath(projectRoot, invalidation.filePath),
     };
   } else {
     invariant(
+      // @ts-expect-error TS2339
       invalidation.aboveFilePath != null && invalidation.fileName != null,
     );
     return {
+      // @ts-expect-error TS2339
       fileName: invalidation.fileName,
+      // @ts-expect-error TS2339
       aboveFilePath: toProjectPath(projectRoot, invalidation.aboveFilePath),
     };
   }
@@ -167,8 +182,8 @@ export function createInvalidations(): Invalidations {
 
 export function fromInternalSourceLocation(
   projectRoot: FilePath,
-  loc: ?InternalSourceLocation,
-): ?SourceLocation {
+  loc?: InternalSourceLocation | null,
+): SourceLocation | null | undefined {
   if (!loc) return loc;
 
   return {
@@ -180,8 +195,8 @@ export function fromInternalSourceLocation(
 
 export function toInternalSourceLocation(
   projectRoot: FilePath,
-  loc: ?SourceLocation,
-): ?InternalSourceLocation {
+  loc?: SourceLocation | null,
+): InternalSourceLocation | null | undefined {
   if (!loc) return loc;
 
   return {
@@ -190,17 +205,33 @@ export function toInternalSourceLocation(
     end: loc.end,
   };
 }
-export function toInternalSymbols<T: {|loc: ?SourceLocation|}>(
+export function toInternalSymbols<
+  T extends {
+    loc: SourceLocation | null | undefined;
+  },
+>(
   projectRoot: FilePath,
-  symbols: ?Map<Symbol, T>,
-): ?Map<
-  Symbol,
-  {|loc: ?InternalSourceLocation, ...$Rest<T, {|loc: ?SourceLocation|}>|},
-> {
+  symbols?: Map<symbol, T> | null,
+):
+  | Map<
+      symbol,
+      {
+        loc: InternalSourceLocation | null | undefined;
+      } & Partial<
+        Diff<
+          T,
+          {
+            loc: SourceLocation | null | undefined;
+          }
+        >
+      >
+    >
+  | null
+  | undefined {
   if (!symbols) return symbols;
 
   return new Map(
-    [...symbols].map(([k, {loc, ...v}]) => [
+    [...symbols].map(([k, {loc, ...v}]: [any, any]) => [
       k,
       {
         ...v,

package/src/{worker.js → worker.ts}

@@ -1,5 +1,3 @@
-// @flow strict-local
-
 import type {
   Bundle,
   AtlaspackOptions,
@@ -14,16 +12,17 @@ import invariant from 'assert';
 import nullthrows from 'nullthrows';
 import BundleGraph from './BundleGraph';
 import Transformation, {
-  type TransformationOpts,
-  type TransformationResult,
+  TransformationOpts,
+  TransformationResult,
 } from './Transformation';
 import {reportWorker, report} from './ReporterRunner';
-import PackagerRunner, {type RunPackagerRunnerResult} from './PackagerRunner';
-import Validation, {type ValidationOpts} from './Validation';
+import PackagerRunner, {RunPackagerRunnerResult} from './PackagerRunner';
+import Validation, {ValidationOpts} from './Validation';
 import {AtlaspackConfig} from './AtlaspackConfig';
 import {registerCoreWithSerializer} from './registerCoreWithSerializer';
 import {clearBuildCaches} from '@atlaspack/build-cache';
-import {init as initSourcemaps} from '@parcel/source-map';
+import {init as initSourcemaps} from '@atlaspack/source-map';
+// @ts-expect-error TS2305
 import {init as initRust} from '@atlaspack/rust';
 import WorkerFarm from '@atlaspack/workers';
 import {setFeatureFlags} from '@atlaspack/feature-flags';
@@ -32,43 +31,48 @@ import '@atlaspack/cache'; // register with serializer
 import '@atlaspack/package-manager';
 import '@atlaspack/fs';
 
-// $FlowFixMe
-if (process.env.ATLASPACK_BUILD_REPL && process.browser) {
-  /* eslint-disable import/no-extraneous-dependencies, monorepo/no-internal-import */
-  require('@atlaspack/repl/src/atlaspack/BrowserPackageManager.js');
-  // $FlowFixMe
-  require('@atlaspack/repl/src/atlaspack/ExtendedMemoryFS.js');
-  /* eslint-enable import/no-extraneous-dependencies, monorepo/no-internal-import */
-}
+// flow-to-ts helpers
+export type SetComplement<A, B extends A> = A extends B ? never : A;
+export type Diff<T extends U, U extends object> = Pick<
+  T,
+  SetComplement<keyof T, keyof U>
+>;
+// /flow-to-ts helpers
 
 registerCoreWithSerializer();
 
 // Remove the workerApi type from the TransformationOpts and ValidationOpts types:
 // https://github.com/facebook/flow/issues/2835
-type WorkerTransformationOpts = {|
-  ...$Diff<TransformationOpts, {|workerApi: mixed, options: AtlaspackOptions|}>,
-  optionsRef: SharedReference,
-  configCachePath: string,
-|};
-type WorkerValidationOpts = {|
-  ...$Diff<ValidationOpts, {|workerApi: mixed, options: AtlaspackOptions|}>,
-  optionsRef: SharedReference,
-  configCachePath: string,
-|};
+type WorkerTransformationOpts = Diff<
+  TransformationOpts,
+  {
+    workerApi: unknown;
+    options: AtlaspackOptions;
+  }
+> & {
+  optionsRef: SharedReference;
+  configCachePath: string;
+};
+type WorkerValidationOpts = Diff<
+  // @ts-expect-error TS2344
+  ValidationOpts,
+  {
+    workerApi: unknown;
+    options: AtlaspackOptions;
+  }
+> & {
+  optionsRef: SharedReference;
+  configCachePath: string;
+};
 
 // TODO: this should eventually be replaced by an in memory cache layer
 let atlaspackConfigCache = new Map();
 
-function loadOptions(ref, workerApi) {
-  return nullthrows(
-    ((workerApi.getSharedReference(
-      ref,
-      // $FlowFixMe
-    ): any): AtlaspackOptions),
-  );
+function loadOptions(ref: SharedReference, workerApi: WorkerApi) {
+  return nullthrows(workerApi.getSharedReference(ref) as AtlaspackOptions);
 }
 
-async function loadConfig(cachePath, options) {
+async function loadConfig(cachePath: string, options: AtlaspackOptions) {
   let config = atlaspackConfigCache.get(cachePath);
   if (config && config.options === options) {
     return config;
@@ -101,6 +105,7 @@ export async function runTransform(
   return new Transformation({
     workerApi,
     options,
+    // @ts-expect-error TS2783
     config,
     ...rest,
   }).run();
@@ -116,8 +121,10 @@ export async function runValidate(
 
   return new Validation({
     workerApi,
+    // @ts-expect-error TS2783
     report: reportWorker.bind(null, workerApi),
     options,
+    // @ts-expect-error TS2783
     config,
     ...rest,
   }).run();
@@ -133,15 +140,15 @@ export async function runPackage(
     previousDevDeps,
     invalidDevDeps,
     previousInvalidations,
-  }: {|
-    bundle: Bundle,
-    bundleGraphReference: SharedReference,
-    configCachePath: string,
-    optionsRef: SharedReference,
-    previousDevDeps: Map<string, string>,
-    invalidDevDeps: Array<DevDepSpecifier>,
-    previousInvalidations: Array<RequestInvalidation>,
-  |},
+  }: {
+    bundle: Bundle;
+    bundleGraphReference: SharedReference;
+    configCachePath: string;
+    optionsRef: SharedReference;
+    previousDevDeps: Map<string, string>;
+    invalidDevDeps: Array<DevDepSpecifier>;
+    previousInvalidations: Array<RequestInvalidation>;
+  },
 ): Promise<RunPackagerRunnerResult> {
   let bundleGraph = workerApi.getSharedReference(bundleGraphReference);
   invariant(bundleGraph instanceof BundleGraph);
@@ -151,6 +158,7 @@ export async function runPackage(
   let runner = new PackagerRunner({
     config: atlaspackConfig,
     options,
+    // @ts-expect-error TS2322
     report: WorkerFarm.isWorker() ? reportWorker.bind(null, workerApi) : report,
     previousDevDeps,
     previousInvalidations,

package/test/{AssetGraph.test.js → AssetGraph.test.ts}

@@ -1,7 +1,7 @@
-// @flow strict-local
 import assert from 'assert';
 import invariant from 'assert';
 import nullthrows from 'nullthrows';
+import {serialize, deserialize} from '@atlaspack/build-cache';
 import AssetGraph, {
   nodeFromAssetGroup,
   nodeFromDep,
@@ -9,24 +9,21 @@ import AssetGraph, {
   nodeFromAsset,
 } from '../src/AssetGraph';
 import {createDependency as _createDependency} from '../src/Dependency';
-import {
-  createAsset as _createAsset,
-  type AssetOptions,
-} from '../src/assetUtils';
+import {createAsset as _createAsset, AssetOptions} from '../src/assetUtils';
 import {DEFAULT_ENV, DEFAULT_TARGETS} from './test-utils';
 import {toProjectPath as _toProjectPath} from '../src/projectPath';
 
-const stats = {size: 0, time: 0};
+const stats = {size: 0, time: 0} as const;
 
 function createAsset(opts: AssetOptions) {
   return _createAsset('/', opts);
 }
 
-function createDependency(opts) {
+function createDependency(opts: any) {
   return _createDependency('/', opts);
 }
 
-function toProjectPath(p) {
+function toProjectPath(p: any) {
   return _toProjectPath('/', p);
 }
 

package/test/{Atlaspack.test.js → Atlaspack.test.ts}

@@ -1,7 +1,6 @@
-// @flow strict-local
-
 import type {InitialAtlaspackOptions} from '@atlaspack/types';
 import WorkerFarm from '@atlaspack/workers';
+import {FILE_CONFIG_NO_REPORTERS} from '@atlaspack/test-utils';
 // flowlint-next-line untyped-import:off
 import sinon from 'sinon';
 import assert from 'assert';
@@ -11,7 +10,7 @@ import Atlaspack, {createWorkerFarm} from '../src/Atlaspack';
 describe('Atlaspack', function () {
   this.timeout(75000);
 
-  let workerFarm;
+  let workerFarm: any;
   before(() => {
     workerFarm = createWorkerFarm();
   });
@@ -22,7 +21,6 @@ describe('Atlaspack', function () {
     workerFarm.ending = true;
     let atlaspack = createAtlaspack({workerFarm});
 
-    // $FlowFixMe
     await assert.rejects(() => atlaspack.run(), {
       name: 'Error',
       message: 'Supplied WorkerFarm is ending',
@@ -32,7 +30,7 @@ describe('Atlaspack', function () {
   });
 
   describe('atlaspack.end()', () => {
-    let endSpy;
+    let endSpy: any;
     beforeEach(() => {
       endSpy = sinon.spy(WorkerFarm.prototype, 'end');
     });
@@ -78,7 +76,7 @@ describe('Atlaspack', function () {
 describe('AtlaspackAPI', function () {
   this.timeout(75000);
 
-  let workerFarm;
+  let workerFarm: any;
   beforeEach(() => {
     workerFarm = createWorkerFarm();
   });
@@ -132,10 +130,7 @@ function createAtlaspack(opts?: InitialAtlaspackOptions) {
   return new Atlaspack({
     entries: [path.join(__dirname, 'fixtures/atlaspack/index.js')],
     logLevel: 'info',
-    defaultConfig: path.join(
-      path.dirname(require.resolve('@atlaspack/test-utils')),
-      '.parcelrc-no-reporters',
-    ),
+    defaultConfig: FILE_CONFIG_NO_REPORTERS,
     shouldDisableCache: true,
     ...opts,
   });

package/test/{AtlaspackConfig.test.js → AtlaspackConfig.test.ts}

@@ -1,5 +1,3 @@
-// @flow strict-local
-
 import assert from 'assert';
 import path from 'path';
 
@@ -138,7 +136,6 @@ describe('AtlaspackConfig', () => {
       );
       let atlaspackConfig = new AtlaspackConfig(config, DEFAULT_OPTIONS);
 
-      // $FlowFixMe
       await assert.rejects(() => atlaspackConfig.getTransformers('test.js'), {
         name: 'Error',
         diagnostics: [
@@ -173,7 +170,6 @@ describe('AtlaspackConfig', () => {
       );
       let code = await DEFAULT_OPTIONS.inputFS.readFile(configFilePath, 'utf8');
 
-      // $FlowFixMe
       await assert.rejects(
         () => parseAndProcessConfig(configFilePath, code, DEFAULT_OPTIONS),
         {
@@ -263,7 +259,6 @@ describe('AtlaspackConfig', () => {
         'index.json',
       );
 
-      // $FlowFixMe
       await assert.rejects(() => atlaspackConfig.getTransformers('test.js'), {
         name: 'Error',
         diagnostics: [

package/test/{AtlaspackConfigRequest.test.js → AtlaspackConfigRequest.test.ts}

@@ -1,4 +1,3 @@
-// @flow
 import assert from 'assert';
 import path from 'path';
 
@@ -24,7 +23,6 @@ describe('AtlaspackConfigRequest', () => {
     it('should require pipeline to be an array', () => {
       assert.throws(() => {
         validateConfigFile(
-          // $FlowExpectedError[incompatible-call]
           {
             filePath: '.parcelrc',
             resolvers: '123',
@@ -39,7 +37,6 @@ describe('AtlaspackConfigRequest', () => {
         validateConfigFile(
           {
             filePath: '.parcelrc',
-            // $FlowExpectedError[incompatible-call]
             resolvers: [1, '123', 5],
           },
           '.parcelrc',
@@ -72,7 +69,6 @@ describe('AtlaspackConfigRequest', () => {
         validateConfigFile(
           {
             filePath: '.parcelrc',
-            // $FlowExpectedError[incompatible-call]
             transformers: ['parcel-transformer-test', '...'],
           },
           '.parcelrc',
@@ -83,7 +79,6 @@ describe('AtlaspackConfigRequest', () => {
     it('should require extends to be a string or array of strings', () => {
       assert.throws(() => {
         validateConfigFile(
-          // $FlowExpectedError[incompatible-call]
           {
             filePath: '.parcelrc',
             extends: 2,
@@ -96,7 +91,6 @@ describe('AtlaspackConfigRequest', () => {
         validateConfigFile(
           {
             filePath: '.parcelrc',
-            // $FlowExpectedError[incompatible-call]
             extends: [2, 7],
           },
           '.parcelrc',
@@ -126,9 +120,9 @@ describe('AtlaspackConfigRequest', () => {
       assert.throws(
         () => {
           validateConfigFile(
-            // $FlowExpectedError
             {
               extends: '@atlaspack/config-default',
+
               '@atlaspack/transformer-js': {
                 inlineEnvironment: false,
               },
@@ -136,10 +130,10 @@ describe('AtlaspackConfigRequest', () => {
             '.parcelrc',
           );
         },
-        (e) => {
+        (e: any) => {
           assert.strictEqual(
             e.diagnostics[0].codeFrames[0].codeHighlights[0].message,
-            `Possible values: "$schema", "bundler", "resolvers", "transformers", "validators", "namers", "packagers", "optimizers", "compressors", "reporters", "runtimes", "filePath", "resolveFrom"`,
+            `Possible values: "$schema", "bundler", "resolvers", "transformers", "validators", "namers", "packagers", "optimizers", "compressors", "reporters", "runtimes", "unstable\\_alias", "filePath", "resolveFrom"`,
           );
           return true;
         },
@@ -396,7 +390,7 @@ describe('AtlaspackConfigRequest', () => {
     });
 
     it('should call a merger function if provided', () => {
-      let merger = (a, b) => [a, b];
+      let merger = (a: any, b: any) => [a, b];
       assert.deepEqual(
         mergeMaps({'*.js': 'base-js'}, {'*.js': 'ext-js'}, merger),
         {'*.js': ['base-js', 'ext-js']},
@@ -512,7 +506,6 @@ describe('AtlaspackConfigRequest', () => {
         validators: {},
       };
 
-      // $FlowFixMe
       assert.deepEqual(mergeConfigs(base, ext), merged);
     });
   });
@@ -608,7 +601,6 @@ describe('AtlaspackConfigRequest', () => {
         column: 14,
       };
 
-      // $FlowFixMe[prop-missing]
       await assert.rejects(
         () => parseAndProcessConfig(configFilePath, code, DEFAULT_OPTIONS),
         {
@@ -646,7 +638,6 @@ describe('AtlaspackConfigRequest', () => {
       );
       let code = await DEFAULT_OPTIONS.inputFS.readFile(configFilePath, 'utf8');
 
-      // $FlowFixMe[prop-missing]
       await assert.rejects(
         () => parseAndProcessConfig(configFilePath, code, DEFAULT_OPTIONS),
         {
@@ -685,7 +676,6 @@ describe('AtlaspackConfigRequest', () => {
       );
       let code = await DEFAULT_OPTIONS.inputFS.readFile(configFilePath, 'utf8');
 
-      // $FlowFixMe[prop-missing]
       await assert.rejects(
         () => parseAndProcessConfig(configFilePath, code, DEFAULT_OPTIONS),
         {
@@ -724,7 +714,6 @@ describe('AtlaspackConfigRequest', () => {
       );
       let code = await DEFAULT_OPTIONS.inputFS.readFile(configFilePath, 'utf8');
 
-      // $FlowFixMe[prop-missing]
       await assert.rejects(
         () => parseAndProcessConfig(configFilePath, code, DEFAULT_OPTIONS),
         {
@@ -763,7 +752,6 @@ describe('AtlaspackConfigRequest', () => {
       );
       let code = await DEFAULT_OPTIONS.inputFS.readFile(configFilePath, 'utf8');
 
-      // $FlowFixMe[prop-missing]
       await assert.rejects(
         () => parseAndProcessConfig(configFilePath, code, DEFAULT_OPTIONS),
         {
@@ -813,6 +801,78 @@ describe('AtlaspackConfigRequest', () => {
     });
   });
 
+  describe('additionalReporters', () => {
+    it('should deduplicate reporters by packageName', async () => {
+      const configPath = path.join(
+        __dirname,
+        'fixtures',
+        'config-with-reporters',
+        '.parcelrc',
+      );
+
+      const options = {
+        ...DEFAULT_OPTIONS,
+        projectRoot: path.join(__dirname, 'fixtures', 'config-with-reporters'),
+        config: configPath,
+        additionalReporters: [
+          {
+            packageName: '@atlaspack/reporter-cli',
+            resolveFrom: '/custom/path',
+          },
+          {
+            packageName: '@atlaspack/reporter-dev-server',
+            resolveFrom: '/another/path',
+          },
+        ],
+      };
+
+      const result = await resolveAtlaspackConfig(options);
+      assert(result !== null && result !== undefined);
+
+      const {config} = result;
+
+      // With feature flag enabled, should have 3 reporters (with deduplication)
+      assert(
+        config.reporters && config.reporters.length === 3,
+        'Should have exactly 3 reporters with deduplication',
+      );
+
+      const cliReporter = config.reporters?.find(
+        (r) => r.packageName === '@atlaspack/reporter-cli',
+      );
+      const bundleAnalyzerReporter = config.reporters?.find(
+        (r) => r.packageName === '@atlaspack/reporter-bundle-analyzer',
+      );
+      const devServerReporter = config.reporters?.find(
+        (r) => r.packageName === '@atlaspack/reporter-dev-server',
+      );
+
+      assert(cliReporter, 'CLI reporter should exist');
+      assert.equal(
+        cliReporter.resolveFrom,
+        '/custom/path',
+        'CLI reporter should use additional reporter resolveFrom',
+      );
+
+      assert(
+        bundleAnalyzerReporter,
+        'Bundle analyzer reporter should exist from original config',
+      );
+
+      assert(devServerReporter, 'Dev server reporter should exist');
+      assert.equal(devServerReporter.resolveFrom, '/another/path');
+
+      const cliReporters = config.reporters?.filter(
+        (r) => r.packageName === '@atlaspack/reporter-cli',
+      );
+      assert.equal(
+        cliReporters?.length,
+        1,
+        'Should have exactly one CLI reporter after deduplication',
+      );
+    });
+  });
+
   describe('resolve', () => {
     it('should return null if there is no .parcelrc file found', async () => {
       let resolved = await resolveAtlaspackConfig(DEFAULT_OPTIONS);