@atlaspack/package-manager 2.14.5-canary.36 → 2.14.5-canary.360

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

@@ -1,4 +1,3 @@
-// @flow
 import type {
   FilePath,
   DependencySpecifier,
@@ -41,14 +40,13 @@ import {transformSync} from '@swc/core';
 // Package.json fields. Must match package_json.rs.
 const MAIN = 1 << 0;
 const SOURCE = 1 << 2;
-const ENTRIES =
-  MAIN |
-  (process.env.ATLASPACK_BUILD_ENV !== 'production' ||
-  process.env.ATLASPACK_SELF_BUILD
-    ? SOURCE
-    : 0);
+let ENTRIES = MAIN;
+if (process.env.ATLASPACK_REGISTER_USE_SRC === 'true') {
+  ENTRIES |= SOURCE;
+}
 
 const NODE_MODULES = `${path.sep}node_modules${path.sep}`;
+const compileExtensions = new Set(['.ts', '.tsx', '.mts', '.cts']);
 
 // There can be more than one instance of NodePackageManager, but node has only a single module cache.
 // Therefore, the resolution cache and the map of parent to child modules should also be global.
@@ -64,25 +62,34 @@ const invalidationsCache = new Map<string, Invalidations>();
 export class NodePackageManager implements PackageManager {
   fs: FileSystem;
   projectRoot: FilePath;
-  installer: ?PackageInstaller;
+  installer: PackageInstaller | null | undefined;
+  // @ts-expect-error TS2749
   resolver: ResolverBase;
   currentExtensions: Array<string>;
+  atlaspackLinkRoot: string | null;
 
   constructor(
     fs: FileSystem,
     projectRoot: FilePath,
-    installer?: ?PackageInstaller,
+    installer?: PackageInstaller | null,
   ) {
     this.fs = fs;
     this.projectRoot = projectRoot;
     this.installer = installer;
 
-    // $FlowFixMe - no type for _extensions
+    // If using src then assume we're linked and find the link root dir
+    this.atlaspackLinkRoot =
+      process.env.ATLASPACK_REGISTER_USE_SRC === 'true'
+        ? path.resolve(__dirname, '../../../..')
+        : null;
+
+    // @ts-expect-error TS2339
     this.currentExtensions = Object.keys(Module._extensions).map((e) =>
       e.substring(1),
     );
   }
 
+  // @ts-expect-error TS2749
   _createResolver(): ResolverBase {
     return new ResolverBase(this.projectRoot, {
       fs:
@@ -99,8 +106,8 @@ export class NodePackageManager implements PackageManager {
       packageExports: true,
       moduleDirResolver:
         process.versions.pnp != null
-          ? (module, from) => {
-              // $FlowFixMe[prop-missing]
+          ? (module: any, from: any) => {
+              // @ts-expect-error TS2339
               let pnp = Module.findPnpApi(path.dirname(from));
 
               return pnp.resolveToUnqualified(
@@ -119,12 +126,12 @@ export class NodePackageManager implements PackageManager {
     return new NodePackageManager(opts.fs, opts.projectRoot, opts.installer);
   }
 
-  serialize(): {|
-    $$raw: boolean,
-    fs: FileSystem,
-    projectRoot: FilePath,
-    installer: ?PackageInstaller,
-  |} {
+  serialize(): {
+    $$raw: boolean;
+    fs: FileSystem;
+    projectRoot: FilePath;
+    installer: PackageInstaller | null | undefined;
+  } {
     return {
       $$raw: false,
       fs: this.fs,
@@ -136,11 +143,11 @@ export class NodePackageManager implements PackageManager {
   async require(
     name: DependencySpecifier,
     from: FilePath,
-    opts: ?{|
-      range?: ?SemverRange,
-      shouldAutoInstall?: boolean,
-      saveDev?: boolean,
-    |},
+    opts?: {
+      range?: SemverRange | null | undefined;
+      shouldAutoInstall?: boolean;
+      saveDev?: boolean;
+    } | null,
   ): Promise<any> {
     let {resolved, type} = await this.resolve(name, from, opts);
     if (type === 2) {
@@ -157,10 +164,10 @@ export class NodePackageManager implements PackageManager {
 
       // On Windows, Node requires absolute paths to be file URLs.
       if (process.platform === 'win32' && path.isAbsolute(resolved)) {
+        // @ts-expect-error TS2322
         resolved = pathToFileURL(resolved);
       }
 
-      // $FlowFixMe
       return import(resolved);
     }
     return this.load(resolved, from);
@@ -174,20 +181,19 @@ export class NodePackageManager implements PackageManager {
   load(filePath: FilePath, from: FilePath): any {
     if (!path.isAbsolute(filePath)) {
       // Node builtin module
-      // $FlowFixMe
       return require(filePath);
     }
 
-    // $FlowFixMe[prop-missing]
+    // @ts-expect-error TS2339
     const cachedModule = Module._cache[filePath];
     if (cachedModule !== undefined) {
       return cachedModule.exports;
     }
 
-    // $FlowFixMe
+    // @ts-expect-error TS2339
     let m = new Module(filePath, Module._cache[from] || module.parent);
 
-    // $FlowFixMe _extensions not in type
+    // @ts-expect-error TS2339
     const extensions = Object.keys(Module._extensions);
     // This handles supported extensions changing due to, for example, esbuild/register being used
     // We assume that the extension list will change in size - as these tools usually add support for
@@ -197,62 +203,82 @@ export class NodePackageManager implements PackageManager {
       this.resolver = this._createResolver();
     }
 
-    // $FlowFixMe[prop-missing]
+    // @ts-expect-error TS2339
     Module._cache[filePath] = m;
 
     // Patch require within this module so it goes through our require
-    m.require = (id) => {
+    m.require = (id: any) => {
       return this.requireSync(id, filePath);
     };
 
     // Patch `fs.readFileSync` temporarily so that it goes through our file system
     let {readFileSync, statSync} = nativeFS;
-    // $FlowFixMe
-    nativeFS.readFileSync = (filename, encoding) => {
+    // @ts-expect-error TS2322
+    nativeFS.readFileSync = (filename: any, encoding: any) => {
       return this.fs.readFileSync(filename, encoding);
     };
 
-    // $FlowFixMe
-    nativeFS.statSync = (filename) => {
+    // @ts-expect-error TS2540
+    nativeFS.statSync = (filename: any) => {
       return this.fs.statSync(filename);
     };
 
-    if (!filePath.includes(NODE_MODULES)) {
-      let extname = path.extname(filePath);
-      if (
-        (extname === '.ts' ||
-          extname === '.tsx' ||
-          extname === '.mts' ||
-          extname === '.cts') &&
-        // $FlowFixMe
-        !Module._extensions[extname]
-      ) {
-        let compile = m._compile;
-        m._compile = (code, filename) => {
-          let out = transformSync(code, {filename, module: {type: 'commonjs'}});
-          compile.call(m, out.code, filename);
-        };
+    let extname = path.extname(filePath);
 
-        // $FlowFixMe
-        Module._extensions[extname] = (m, filename) => {
-          // $FlowFixMe
-          delete Module._extensions[extname];
-          // $FlowFixMe
-          Module._extensions['.js'](m, filename);
-        };
+    function shouldCompile(atlaspackLinkRoot: string | null): boolean {
+      if (filePath.includes(NODE_MODULES)) {
+        // Don't compile node_modules
+        return false;
+      }
+
+      if (!compileExtensions.has(extname)) {
+        // Ignore non-TS files
+        return false;
+      }
+
+      if (atlaspackLinkRoot != null) {
+        // If we're linked, only compile files outside the linked atlaspack
+        // as those are handled by @atlaspack/babel-register
+        return !filePath.startsWith(atlaspackLinkRoot);
       }
+
+      // @ts-expect-error TS2339
+      // Lastly make sure there's no existing loader for this extension
+      return !Module._extensions[extname];
+    }
+
+    if (shouldCompile(this.atlaspackLinkRoot)) {
+      // @ts-expect-error TS2339
+      let compile = m._compile;
+      // @ts-expect-error TS2339
+      m._compile = (code: any, filename: any) => {
+        let out = transformSync(code, {
+          filename,
+          module: {type: 'commonjs'},
+          env: {targets: {node: '18'}},
+        });
+        compile.call(m, out.code, filename);
+      };
+
+      // @ts-expect-error TS2339
+      Module._extensions[extname] = (m: any, filename: any) => {
+        // @ts-expect-error TS2339
+        delete Module._extensions[extname];
+        // @ts-expect-error TS2339
+        Module._extensions['.js'](m, filename);
+      };
     }
 
     try {
+      // @ts-expect-error TS2339
       m.load(filePath);
-    } catch (err) {
-      // $FlowFixMe[prop-missing]
+    } catch (err: any) {
+      // @ts-expect-error TS2339
       delete Module._cache[filePath];
       throw err;
     } finally {
-      // $FlowFixMe
       nativeFS.readFileSync = readFileSync;
-      // $FlowFixMe
+      // @ts-expect-error TS2540
       nativeFS.statSync = statSync;
     }
 
@@ -262,11 +288,11 @@ export class NodePackageManager implements PackageManager {
   async resolve(
     id: DependencySpecifier,
     from: FilePath,
-    options?: ?{|
-      range?: ?SemverRange,
-      shouldAutoInstall?: boolean,
-      saveDev?: boolean,
-    |},
+    options?: {
+      range?: SemverRange | null | undefined;
+      shouldAutoInstall?: boolean;
+      saveDev?: boolean;
+    } | null,
   ): Promise<PackageManagerResolveResult> {
     let basedir = path.dirname(from);
     let key = basedir + ':' + id;
@@ -275,7 +301,7 @@ export class NodePackageManager implements PackageManager {
       let [name] = getModuleParts(id);
       try {
         resolved = this.resolveInternal(id, from);
-      } catch (e) {
+      } catch (e: any) {
         if (
           e.code !== 'MODULE_NOT_FOUND' ||
           options?.shouldAutoInstall !== true ||
@@ -293,7 +319,7 @@ export class NodePackageManager implements PackageManager {
                 ],
               },
             });
-            // $FlowFixMe - needed for loadParcelPlugin
+            // @ts-expect-error TS2339
             err.code = 'MODULE_NOT_FOUND';
             throw err;
           } else {
@@ -476,7 +502,10 @@ export class NodePackageManager implements PackageManager {
       };
 
       let seen = new Set();
-      let addKey = (name, from) => {
+      let addKey = (
+        name: DependencySpecifier,
+        from: FilePath | DependencySpecifier,
+      ) => {
         let basedir = path.dirname(from);
         let key = basedir + ':' + name;
         if (seen.has(key)) {
@@ -489,6 +518,7 @@ export class NodePackageManager implements PackageManager {
           return;
         }
 
+        // @ts-expect-error TS2345
         res.invalidateOnFileCreate.push(...resolved.invalidateOnFileCreate);
         res.invalidateOnFileChange.add(resolved.resolved);
 
@@ -510,10 +540,13 @@ export class NodePackageManager implements PackageManager {
       // cannot be intercepted. Instead, ask the resolver to parse the file and recursively analyze the deps.
       if (resolved.type === 2) {
         let invalidations = this.resolver.getInvalidations(resolved.resolved);
+        // @ts-expect-error TS7006
         invalidations.invalidateOnFileChange.forEach((i) =>
           res.invalidateOnFileChange.add(i),
         );
+        // @ts-expect-error TS7006
         invalidations.invalidateOnFileCreate.forEach((i) =>
+          // @ts-expect-error TS2345
           res.invalidateOnFileCreate.push(i),
         );
         res.invalidateOnStartup ||= invalidations.invalidateOnStartup;
@@ -528,7 +561,9 @@ export class NodePackageManager implements PackageManager {
         }
       }
 
+      // @ts-expect-error TS2345
       invalidationsCache.set(resolved.resolved, res);
+      // @ts-expect-error TS2322
       return res;
     }
 
@@ -542,7 +577,10 @@ export class NodePackageManager implements PackageManager {
   invalidate(name: DependencySpecifier, from: FilePath) {
     let seen = new Set();
 
-    let invalidate = (name, from) => {
+    let invalidate = (
+      name: DependencySpecifier,
+      from: FilePath | DependencySpecifier,
+    ) => {
       let basedir = path.dirname(from);
       let key = basedir + ':' + name;
       if (seen.has(key)) {
@@ -555,12 +593,24 @@ export class NodePackageManager implements PackageManager {
         return;
       }
 
+      // During testing don't invalidate Atlaspack modules because
+      // this causes failures due to multiple instances of the same module
+      // existing simultaniously. This is fine when using babe;-register because
+      // it has an internal module cache that NodePacakageManager does not invalidate
+      // but fails when using compiled Atlaspack packages in integration tests
+      if (
+        process.env.ATLASPACK_BUILD_ENV === 'test' &&
+        name.startsWith('@atlaspack/')
+      ) {
+        return;
+      }
+
       invalidationsCache.delete(resolved.resolved);
 
-      // $FlowFixMe
+      // @ts-expect-error TS2339
       let module = Module._cache[resolved.resolved];
       if (module) {
-        // $FlowFixMe
+        // @ts-expect-error TS2339
         delete Module._cache[resolved.resolved];
       }
 
@@ -594,17 +644,18 @@ export class NodePackageManager implements PackageManager {
     // Invalidate whenever the .pnp.js file changes.
     // TODO: only when we actually resolve a node_modules package?
     if (process.versions.pnp != null && res.invalidateOnFileChange) {
-      // $FlowFixMe[prop-missing]
+      // @ts-expect-error TS2339
       let pnp = Module.findPnpApi(path.dirname(from));
       res.invalidateOnFileChange.push(pnp.resolveToUnqualified('pnpapi', null));
     }
 
     if (res.error) {
       let e = new Error(`Could not resolve module "${name}" from "${from}"`);
-      // $FlowFixMe
+      // @ts-expect-error TS2339
       e.code = 'MODULE_NOT_FOUND';
       throw e;
     }
+    // @ts-expect-error TS7034
     let getPkg;
     switch (res.resolution.type) {
       case 'Path':
@@ -626,6 +677,7 @@ export class NodePackageManager implements PackageManager {
           invalidateOnFileCreate: res.invalidateOnFileCreate,
           type: res.moduleType,
           get pkg() {
+            // @ts-expect-error TS7005
             return getPkg();
           },
         };

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

@@ -1,15 +1,13 @@
-// @flow strict-local
-
 import type {PackageInstaller, InstallerOptions} from '@atlaspack/types';
 
 import path from 'path';
+// @ts-expect-error TS7016
 import spawn from 'cross-spawn';
 import logger from '@atlaspack/logger';
 import {registerSerializableClass} from '@atlaspack/build-cache';
 import promiseFromProcess from './promiseFromProcess';
 import {npmSpecifierFromModuleRequest} from './utils';
 
-// $FlowFixMe
 import pkg from '../package.json';
 
 const NPM_CMD = 'npm';
@@ -35,7 +33,7 @@ export class Npm implements PackageInstaller {
     // When Parcel is run by npm (e.g. via package.json scripts), several environment variables are
     // added. When parcel in turn calls npm again, these can cause npm to behave stragely, so we
     // filter them out when installing packages.
-    let env = {};
+    let env: Record<string, any> = {};
     for (let key in process.env) {
       if (!key.startsWith('npm_') && key !== 'INIT_CWD' && key !== 'NODE_ENV') {
         env[key] = process.env[key];
@@ -48,7 +46,7 @@ export class Npm implements PackageInstaller {
       stdout += buf.toString();
     });
 
-    let stderr = [];
+    let stderr: Array<string> = [];
     installProcess.stderr.on('data', (buf: Buffer) => {
       stderr.push(buf.toString().trim());
     });
@@ -76,7 +74,7 @@ export class Npm implements PackageInstaller {
           });
         }
       }
-    } catch (e) {
+    } catch (e: any) {
       throw new Error(
         'npm failed to install modules: ' +
           e.message +
@@ -87,8 +85,10 @@ export class Npm implements PackageInstaller {
   }
 }
 
-type NPMResults = {|
-  added: Array<{name: string, ...}>,
-|};
+type NPMResults = {
+  added: Array<{
+    name: string;
+  }>;
+};
 
 registerSerializableClass(`${pkg.version}:Npm`, Npm);

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

@@ -1,70 +1,83 @@
-// @flow strict-local
-
 import type {PackageInstaller, InstallerOptions} from '@atlaspack/types';
 
 import path from 'path';
 import fs from 'fs';
+// @ts-expect-error TS7016
 import commandExists from 'command-exists';
+// @ts-expect-error TS7016
 import spawn from 'cross-spawn';
 import {registerSerializableClass} from '@atlaspack/build-cache';
 import logger from '@atlaspack/logger';
+// @ts-expect-error TS7016
 import split from 'split2';
 import JSONParseStream from './JSONParseStream';
 import promiseFromProcess from './promiseFromProcess';
 import {exec, npmSpecifierFromModuleRequest} from './utils';
 
-// $FlowFixMe
 import pkg from '../package.json';
 
 const PNPM_CMD = 'pnpm';
 
 type LogLevel = 'error' | 'warn' | 'info' | 'debug';
 
-type ErrorLog = {|
-  err: {|
-    message: string,
-    code: string,
-    stack: string,
-  |},
-|};
+type ErrorLog = {
+  err: {
+    message: string;
+    code: string;
+    stack: string;
+  };
+};
 
 type PNPMLog =
-  | {|
-      +name: 'pnpm:progress',
-      packageId: string,
-      status: 'fetched' | 'found_in_store' | 'resolved',
-    |}
-  | {|
-      +name: 'pnpm:root',
-      added?: {|
-        id?: string,
-        name: string,
-        realName: string,
-        version?: string,
-        dependencyType?: 'prod' | 'dev' | 'optional',
-        latest?: string,
-        linkedFrom?: string,
-      |},
-      removed?: {|
-        name: string,
-        version?: string,
-        dependencyType?: 'prod' | 'dev' | 'optional',
-      |},
-    |}
-  | {|+name: 'pnpm:importing', from: string, method: string, to: string|}
-  | {|+name: 'pnpm:link', target: string, link: string|}
-  | {|+name: 'pnpm:stats', prefix: string, removed?: number, added?: number|};
-
-type PNPMResults = {|
-  level: LogLevel,
-  prefix?: string,
-  message?: string,
-  ...ErrorLog,
-  ...PNPMLog,
-|};
-
-let hasPnpm: ?boolean;
-let pnpmVersion: ?number;
+  | {
+      readonly name: 'pnpm:progress';
+      packageId: string;
+      status: 'fetched' | 'found_in_store' | 'resolved';
+    }
+  | {
+      readonly name: 'pnpm:root';
+      added?: {
+        id?: string;
+        name: string;
+        realName: string;
+        version?: string;
+        dependencyType?: 'prod' | 'dev' | 'optional';
+        latest?: string;
+        linkedFrom?: string;
+      };
+      removed?: {
+        name: string;
+        version?: string;
+        dependencyType?: 'prod' | 'dev' | 'optional';
+      };
+    }
+  | {
+      readonly name: 'pnpm:importing';
+      from: string;
+      method: string;
+      to: string;
+    }
+  | {
+      readonly name: 'pnpm:link';
+      target: string;
+      link: string;
+    }
+  | {
+      readonly name: 'pnpm:stats';
+      prefix: string;
+      removed?: number;
+      added?: number;
+    };
+
+type PNPMResults = {
+  level: LogLevel;
+  prefix?: string;
+  message?: string;
+} & ErrorLog &
+  PNPMLog;
+
+let hasPnpm: boolean | null | undefined;
+let pnpmVersion: number | null | undefined;
 
 export class Pnpm implements PackageInstaller {
   static async exists(): Promise<boolean> {
@@ -74,7 +87,7 @@ export class Pnpm implements PackageInstaller {
 
     try {
       hasPnpm = Boolean(await commandExists('pnpm'));
-    } catch (err) {
+    } catch (err: any) {
       hasPnpm = false;
     }
 
@@ -88,6 +101,7 @@ export class Pnpm implements PackageInstaller {
   }: InstallerOptions): Promise<void> {
     if (pnpmVersion == null) {
       let version = await exec('pnpm --version');
+      // @ts-expect-error TS2345
       pnpmVersion = parseInt(version.stdout, 10);
     }
 
@@ -106,7 +120,7 @@ export class Pnpm implements PackageInstaller {
     }
     args = args.concat(modules.map(npmSpecifierFromModuleRequest));
 
-    let env = {};
+    let env: Record<string, any> = {};
     for (let key in process.env) {
       if (!key.startsWith('npm_') && key !== 'INIT_CWD' && key !== 'NODE_ENV') {
         env[key] = process.env[key];
@@ -122,7 +136,9 @@ export class Pnpm implements PackageInstaller {
     });
     installProcess.stdout
       .pipe(split())
+      // @ts-expect-error TS2554
       .pipe(new JSONParseStream())
+      // @ts-expect-error TS7006
       .on('error', (e) => {
         logger.warn({
           origin: '@atlaspack/package-manager',
@@ -148,11 +164,13 @@ export class Pnpm implements PackageInstaller {
         }
       });
 
-    let stderr = [];
+    let stderr: Array<any> = [];
     installProcess.stderr
+      // @ts-expect-error TS7006
       .on('data', (str) => {
         stderr.push(str.toString());
       })
+      // @ts-expect-error TS7006
       .on('error', (e) => {
         logger.warn({
           origin: '@atlaspack/package-manager',
@@ -181,7 +199,7 @@ export class Pnpm implements PackageInstaller {
           message,
         });
       }
-    } catch (e) {
+    } catch (e: any) {
       throw new Error('pnpm failed to install modules');
     }
   }