@atlaspack/package-manager 2.14.21-typescript-bc4459c37.0 → 2.14.21

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

@@ -1,3 +1,4 @@
+// @flow
 import type {
   FilePath,
   DependencySpecifier,
@@ -61,27 +62,25 @@ const invalidationsCache = new Map<string, Invalidations>();
 export class NodePackageManager implements PackageManager {
   fs: FileSystem;
   projectRoot: FilePath;
-  installer: PackageInstaller | null | undefined;
-  // @ts-expect-error TS2749
+  installer: ?PackageInstaller;
   resolver: ResolverBase;
   currentExtensions: Array<string>;
 
   constructor(
     fs: FileSystem,
     projectRoot: FilePath,
-    installer?: PackageInstaller | null,
+    installer?: ?PackageInstaller,
   ) {
     this.fs = fs;
     this.projectRoot = projectRoot;
     this.installer = installer;
 
-    // @ts-expect-error TS2339
+    // $FlowFixMe - no type for _extensions
     this.currentExtensions = Object.keys(Module._extensions).map((e) =>
       e.substring(1),
     );
   }
 
-  // @ts-expect-error TS2749
   _createResolver(): ResolverBase {
     return new ResolverBase(this.projectRoot, {
       fs:
@@ -98,8 +97,8 @@ export class NodePackageManager implements PackageManager {
       packageExports: true,
       moduleDirResolver:
         process.versions.pnp != null
-          ? (module: any, from: any) => {
-              // @ts-expect-error TS2339
+          ? (module, from) => {
+              // $FlowFixMe[prop-missing]
               let pnp = Module.findPnpApi(path.dirname(from));
 
               return pnp.resolveToUnqualified(
@@ -118,12 +117,12 @@ export class NodePackageManager implements PackageManager {
     return new NodePackageManager(opts.fs, opts.projectRoot, opts.installer);
   }
 
-  serialize(): {
-    $$raw: boolean;
-    fs: FileSystem;
-    projectRoot: FilePath;
-    installer: PackageInstaller | null | undefined;
-  } {
+  serialize(): {|
+    $$raw: boolean,
+    fs: FileSystem,
+    projectRoot: FilePath,
+    installer: ?PackageInstaller,
+  |} {
     return {
       $$raw: false,
       fs: this.fs,
@@ -135,11 +134,11 @@ export class NodePackageManager implements PackageManager {
   async require(
     name: DependencySpecifier,
     from: FilePath,
-    opts?: {
-      range?: SemverRange | null | undefined;
-      shouldAutoInstall?: boolean;
-      saveDev?: boolean;
-    } | null,
+    opts: ?{|
+      range?: ?SemverRange,
+      shouldAutoInstall?: boolean,
+      saveDev?: boolean,
+    |},
   ): Promise<any> {
     let {resolved, type} = await this.resolve(name, from, opts);
     if (type === 2) {
@@ -156,10 +155,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);
@@ -173,19 +172,20 @@ export class NodePackageManager implements PackageManager {
   load(filePath: FilePath, from: FilePath): any {
     if (!path.isAbsolute(filePath)) {
       // Node builtin module
+      // $FlowFixMe
       return require(filePath);
     }
 
-    // @ts-expect-error TS2339
+    // $FlowFixMe[prop-missing]
     const cachedModule = Module._cache[filePath];
     if (cachedModule !== undefined) {
       return cachedModule.exports;
     }
 
-    // @ts-expect-error TS2339
+    // $FlowFixMe
     let m = new Module(filePath, Module._cache[from] || module.parent);
 
-    // @ts-expect-error TS2339
+    // $FlowFixMe _extensions not in type
     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
@@ -195,23 +195,23 @@ export class NodePackageManager implements PackageManager {
       this.resolver = this._createResolver();
     }
 
-    // @ts-expect-error TS2339
+    // $FlowFixMe[prop-missing]
     Module._cache[filePath] = m;
 
     // Patch require within this module so it goes through our require
-    m.require = (id: any) => {
+    m.require = (id) => {
       return this.requireSync(id, filePath);
     };
 
     // Patch `fs.readFileSync` temporarily so that it goes through our file system
     let {readFileSync, statSync} = nativeFS;
-    // @ts-expect-error TS2322
-    nativeFS.readFileSync = (filename: any, encoding: any) => {
+    // $FlowFixMe
+    nativeFS.readFileSync = (filename, encoding) => {
       return this.fs.readFileSync(filename, encoding);
     };
 
-    // @ts-expect-error TS2540
-    nativeFS.statSync = (filename: any) => {
+    // $FlowFixMe
+    nativeFS.statSync = (filename) => {
       return this.fs.statSync(filename);
     };
 
@@ -222,37 +222,35 @@ export class NodePackageManager implements PackageManager {
           extname === '.tsx' ||
           extname === '.mts' ||
           extname === '.cts') &&
-        // @ts-expect-error TS2339
+        // $FlowFixMe
         !Module._extensions[extname]
       ) {
-        // @ts-expect-error TS2339
         let compile = m._compile;
-        // @ts-expect-error TS2339
-        m._compile = (code: any, filename: any) => {
+        m._compile = (code, filename) => {
           let out = transformSync(code, {filename, module: {type: 'commonjs'}});
           compile.call(m, out.code, filename);
         };
 
-        // @ts-expect-error TS2339
-        Module._extensions[extname] = (m: any, filename: any) => {
-          // @ts-expect-error TS2339
+        // $FlowFixMe
+        Module._extensions[extname] = (m, filename) => {
+          // $FlowFixMe
           delete Module._extensions[extname];
-          // @ts-expect-error TS2339
+          // $FlowFixMe
           Module._extensions['.js'](m, filename);
         };
       }
     }
 
     try {
-      // @ts-expect-error TS2339
       m.load(filePath);
-    } catch (err: any) {
-      // @ts-expect-error TS2339
+    } catch (err) {
+      // $FlowFixMe[prop-missing]
       delete Module._cache[filePath];
       throw err;
     } finally {
+      // $FlowFixMe
       nativeFS.readFileSync = readFileSync;
-      // @ts-expect-error TS2540
+      // $FlowFixMe
       nativeFS.statSync = statSync;
     }
 
@@ -262,11 +260,11 @@ export class NodePackageManager implements PackageManager {
   async resolve(
     id: DependencySpecifier,
     from: FilePath,
-    options?: {
-      range?: SemverRange | null | undefined;
-      shouldAutoInstall?: boolean;
-      saveDev?: boolean;
-    } | null,
+    options?: ?{|
+      range?: ?SemverRange,
+      shouldAutoInstall?: boolean,
+      saveDev?: boolean,
+    |},
   ): Promise<PackageManagerResolveResult> {
     let basedir = path.dirname(from);
     let key = basedir + ':' + id;
@@ -275,7 +273,7 @@ export class NodePackageManager implements PackageManager {
       let [name] = getModuleParts(id);
       try {
         resolved = this.resolveInternal(id, from);
-      } catch (e: any) {
+      } catch (e) {
         if (
           e.code !== 'MODULE_NOT_FOUND' ||
           options?.shouldAutoInstall !== true ||
@@ -293,7 +291,7 @@ export class NodePackageManager implements PackageManager {
                 ],
               },
             });
-            // @ts-expect-error TS2339
+            // $FlowFixMe - needed for loadParcelPlugin
             err.code = 'MODULE_NOT_FOUND';
             throw err;
           } else {
@@ -322,7 +320,6 @@ export class NodePackageManager implements PackageManager {
 
         throw new ThrowableDiagnostic({
           diagnostic: conflicts.fields.map((field) => ({
-            // @ts-expect-error TS2345
             message: md`Could not find module "${name}", but it was listed in package.json. Run your package manager first.`,
             origin: '@atlaspack/package-manager',
             codeFrames: [
@@ -364,7 +361,6 @@ export class NodePackageManager implements PackageManager {
           } else if (conflicts != null) {
             throw new ThrowableDiagnostic({
               diagnostic: {
-                // @ts-expect-error TS2345
                 message: md`Could not find module "${name}" satisfying ${range}.`,
                 origin: '@atlaspack/package-manager',
                 codeFrames: [
@@ -387,10 +383,8 @@ export class NodePackageManager implements PackageManager {
           }
 
           let version = pkg?.version;
-          // @ts-expect-error TS2345
           let message = md`Could not resolve package "${name}" that satisfies ${range}.`;
           if (version != null) {
-            // @ts-expect-error TS2345
             message += md` Found ${version}.`;
           }
 
@@ -480,10 +474,7 @@ export class NodePackageManager implements PackageManager {
       };
 
       let seen = new Set();
-      let addKey = (
-        name: DependencySpecifier,
-        from: FilePath | DependencySpecifier,
-      ) => {
+      let addKey = (name, from) => {
         let basedir = path.dirname(from);
         let key = basedir + ':' + name;
         if (seen.has(key)) {
@@ -496,7 +487,6 @@ export class NodePackageManager implements PackageManager {
           return;
         }
 
-        // @ts-expect-error TS2345
         res.invalidateOnFileCreate.push(...resolved.invalidateOnFileCreate);
         res.invalidateOnFileChange.add(resolved.resolved);
 
@@ -518,19 +508,15 @@ 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;
         if (res.invalidateOnStartup) {
           logger.warn({
-            // @ts-expect-error TS2345
             message: md`${path.relative(
               this.projectRoot,
               resolved.resolved,
@@ -540,9 +526,7 @@ export class NodePackageManager implements PackageManager {
         }
       }
 
-      // @ts-expect-error TS2345
       invalidationsCache.set(resolved.resolved, res);
-      // @ts-expect-error TS2322
       return res;
     }
 
@@ -556,10 +540,7 @@ export class NodePackageManager implements PackageManager {
   invalidate(name: DependencySpecifier, from: FilePath) {
     let seen = new Set();
 
-    let invalidate = (
-      name: DependencySpecifier,
-      from: FilePath | DependencySpecifier,
-    ) => {
+    let invalidate = (name, from) => {
       let basedir = path.dirname(from);
       let key = basedir + ':' + name;
       if (seen.has(key)) {
@@ -586,10 +567,10 @@ export class NodePackageManager implements PackageManager {
 
       invalidationsCache.delete(resolved.resolved);
 
-      // @ts-expect-error TS2339
+      // $FlowFixMe
       let module = Module._cache[resolved.resolved];
       if (module) {
-        // @ts-expect-error TS2339
+        // $FlowFixMe
         delete Module._cache[resolved.resolved];
       }
 
@@ -623,18 +604,17 @@ 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) {
-      // @ts-expect-error TS2339
+      // $FlowFixMe[prop-missing]
       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}"`);
-      // @ts-expect-error TS2339
+      // $FlowFixMe
       e.code = 'MODULE_NOT_FOUND';
       throw e;
     }
-    // @ts-expect-error TS7034
     let getPkg;
     switch (res.resolution.type) {
       case 'Path':
@@ -656,7 +636,6 @@ export class NodePackageManager implements PackageManager {
           invalidateOnFileCreate: res.invalidateOnFileCreate,
           type: res.moduleType,
           get pkg() {
-            // @ts-expect-error TS7005
             return getPkg();
           },
         };

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

@@ -1,13 +1,15 @@
+// @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';
@@ -33,7 +35,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: Record<string, any> = {};
+    let env = {};
     for (let key in process.env) {
       if (!key.startsWith('npm_') && key !== 'INIT_CWD' && key !== 'NODE_ENV') {
         env[key] = process.env[key];
@@ -46,7 +48,7 @@ export class Npm implements PackageInstaller {
       stdout += buf.toString();
     });
 
-    let stderr: Array<string> = [];
+    let stderr = [];
     installProcess.stderr.on('data', (buf: Buffer) => {
       stderr.push(buf.toString().trim());
     });
@@ -74,7 +76,7 @@ export class Npm implements PackageInstaller {
           });
         }
       }
-    } catch (e: any) {
+    } catch (e) {
       throw new Error(
         'npm failed to install modules: ' +
           e.message +
@@ -85,10 +87,8 @@ 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.ts → Pnpm.js}

@@ -1,83 +1,70 @@
+// @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 =
-  | {
-      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;
+  | {|
+      +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;
 
 export class Pnpm implements PackageInstaller {
   static async exists(): Promise<boolean> {
@@ -87,7 +74,7 @@ export class Pnpm implements PackageInstaller {
 
     try {
       hasPnpm = Boolean(await commandExists('pnpm'));
-    } catch (err: any) {
+    } catch (err) {
       hasPnpm = false;
     }
 
@@ -101,7 +88,6 @@ 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);
     }
 
@@ -120,7 +106,7 @@ export class Pnpm implements PackageInstaller {
     }
     args = args.concat(modules.map(npmSpecifierFromModuleRequest));
 
-    let env: Record<string, any> = {};
+    let env = {};
     for (let key in process.env) {
       if (!key.startsWith('npm_') && key !== 'INIT_CWD' && key !== 'NODE_ENV') {
         env[key] = process.env[key];
@@ -136,9 +122,7 @@ 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',
@@ -164,13 +148,11 @@ export class Pnpm implements PackageInstaller {
         }
       });
 
-    let stderr: Array<any> = [];
+    let stderr = [];
     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',
@@ -199,7 +181,7 @@ export class Pnpm implements PackageInstaller {
           message,
         });
       }
-    } catch (e: any) {
+    } catch (e) {
       throw new Error('pnpm failed to install modules');
     }
   }