@atlaspack/package-manager 2.14.21 → 2.14.22-typescript-5ad950d33.0

package/lib/index.d.ts

@@ -1,10 +1,10 @@
-import type { PackageManagerResolveResult } from "@atlaspack/types";
-export type { PackageManager, Invalidations, PackageInstaller, ModuleRequest } from "@atlaspack/types";
-export * from "./Npm";
-export * from "./Pnpm";
-export * from "./Yarn";
-export * from "./MockPackageInstaller";
-export * from "./NodePackageManager";
-export { _addToInstallQueue } from "./installPackage";
+import type { PackageManagerResolveResult } from '@atlaspack/types';
+export type { PackageManager, Invalidations, PackageInstaller, ModuleRequest, } from '@atlaspack/types';
+export * from './Npm';
+export * from './Pnpm';
+export * from './Yarn';
+export * from './MockPackageInstaller';
+export * from './NodePackageManager';
+export { _addToInstallQueue } from './installPackage';
 export type { PackageManagerResolveResult };
 export type { PackageManagerResolveResult as ResolveResult };

package/lib/installPackage.d.ts

@@ -0,0 +1,5 @@
+import type { FilePath } from '@atlaspack/types';
+import type { ModuleRequest, PackageManager, InstallOptions } from '@atlaspack/types';
+import type { FileSystem } from '@atlaspack/fs';
+export declare function _addToInstallQueue(fs: FileSystem, packageManager: PackageManager, modules: Array<ModuleRequest>, filePath: FilePath, projectRoot: FilePath, options?: InstallOptions): Promise<unknown>;
+export declare function installPackage(fs: FileSystem, packageManager: PackageManager, modules: Array<ModuleRequest>, filePath: FilePath, projectRoot: FilePath, options?: InstallOptions): Promise<unknown>;

package/lib/installPackage.js

@@ -116,6 +116,7 @@ async function installPeerDependencies(fs, packageManager, module, from, project
       if (!_semver().default.satisfies(pkg.version, range)) {
         throw new (_diagnostic().default)({
           diagnostic: {
+            // @ts-expect-error TS2345
             message: (0, _diagnostic().md)`Could not install the peer dependency "${name}" for "${module.name}", installed version ${pkg.version} is incompatible with ${range}`,
             origin: '@atlaspack/package-manager',
             codeFrames: [{

package/lib/nodejsConditions.d.ts

@@ -0,0 +1,3 @@
+export declare const defaultNodejsConditions: Array<string>;
+/** @description Gets the export conditions from NODE_OPTIONS and node arguments */
+export declare function getConditionsFromEnv(): Array<string>;

package/lib/nodejsConditions.js

@@ -15,6 +15,7 @@ function _process() {
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 // https://nodejs.org/api/packages.html#conditional-exports
 // TODO We don't support { "type": "module" }
+// @ts-expect-error TS4104
 const defaultNodejsConditions = exports.defaultNodejsConditions = Object.freeze(['node-addons', 'node',
 // 'import',
 'require', 'module-sync', 'default']);
@@ -26,10 +27,15 @@ function getConditionsFromEnv() {
     const conditions = [];
     for (const arg of [..._process().default.execArgv, ...(_process().default.env.NODE_OPTIONS || '').split(' ')]) {
       if (arg.startsWith('--conditions=')) {
+        // @ts-expect-error TS2345
         conditions.push(arg.substring(13));
       }
     }
+
+    // @ts-expect-error TS4104
     envConditions = Object.freeze([...conditions, ...defaultNodejsConditions]);
   }
+
+  // @ts-expect-error TS2322
   return envConditions;
 }

package/lib/promiseFromProcess.d.ts

@@ -0,0 +1,2 @@
+import type { ChildProcess } from 'child_process';
+export default function promiseFromProcess(childProcess: ChildProcess): Promise<void>;

package/lib/promiseFromProcess.js

@@ -12,6 +12,8 @@ function promiseFromProcess(childProcess) {
         reject(new Error('Child process failed'));
         return;
       }
+
+      // @ts-expect-error TS2794
       resolve();
     });
   });

package/lib/utils.d.ts

@@ -0,0 +1,15 @@
+import type { FilePath, ModuleRequest } from '@atlaspack/types';
+import type { FileSystem } from '@atlaspack/fs';
+export declare const exec: (command: string, options?: child_process.execOpts) => Promise<{
+    stdout: string | Buffer;
+    stderr: string | Buffer;
+}>;
+export declare function npmSpecifierFromModuleRequest(moduleRequest: ModuleRequest): string;
+export declare function moduleRequestsFromDependencyMap(dependencyMap: {
+    [key: string]: string;
+}): Array<ModuleRequest>;
+export declare function getConflictingLocalDependencies(fs: FileSystem, name: string, local: FilePath, projectRoot: FilePath): Promise<{
+    json: string;
+    filePath: FilePath;
+    fields: Array<string>;
+} | null | undefined>;

package/lib/validateModuleSpecifier.d.ts

@@ -0,0 +1 @@
+export default function validateModuleSpecifier(moduleName: string): string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaspack/package-manager",
-  "version": "2.14.21",
+  "version": "2.14.22-typescript-5ad950d33.0",
   "description": "Blazing fast, zero configuration web application bundler",
   "license": "(MIT OR Apache-2.0)",
   "publishConfig": {
@@ -10,15 +10,14 @@
     "type": "git",
     "url": "https://github.com/atlassian-labs/atlaspack.git"
   },
-  "main": "lib/index.js",
-  "source": "src/index.js",
-  "types": "index.d.ts",
+  "main": "./lib/index.js",
+  "source": "./src/index.ts",
+  "types": "./lib/index.d.ts",
   "engines": {
     "node": ">= 16.0.0"
   },
   "scripts": {
-    "build-ts": "mkdir -p lib && flow-to-ts src/index.js > lib/index.d.ts",
-    "check-ts": "tsc --noEmit index.d.ts",
+    "check-ts": "tsc --emitDeclarationOnly --rootDir src",
     "test": "mocha test"
   },
   "targets": {
@@ -39,19 +38,19 @@
     }
   },
   "dependencies": {
-    "@atlaspack/build-cache": "2.13.3",
-    "@atlaspack/diagnostic": "2.14.1",
-    "@atlaspack/fs": "2.15.16",
-    "@atlaspack/logger": "2.14.13",
-    "@atlaspack/node-resolver-core": "3.5.21",
-    "@atlaspack/types": "2.15.11",
-    "@atlaspack/utils": "2.17.3",
-    "@atlaspack/workers": "2.14.21",
+    "@atlaspack/build-cache": "2.13.4-typescript-5ad950d33.0",
+    "@atlaspack/diagnostic": "2.14.2-typescript-5ad950d33.0",
+    "@atlaspack/fs": "2.15.17-typescript-5ad950d33.0",
+    "@atlaspack/logger": "2.14.14-typescript-5ad950d33.0",
+    "@atlaspack/node-resolver-core": "3.5.22-typescript-5ad950d33.0",
+    "@atlaspack/types": "2.15.12-typescript-5ad950d33.0",
+    "@atlaspack/utils": "2.17.4-typescript-5ad950d33.0",
+    "@atlaspack/workers": "2.14.22-typescript-5ad950d33.0",
     "@swc/core": "^1.10.0",
-    "semver": "^7.5.2",
     "command-exists": "^1.2.6",
     "cross-spawn": "^6.0.4",
     "nullthrows": "^1.1.1",
+    "semver": "^7.5.2",
     "split2": "^3.1.1"
   },
   "browser": {
@@ -60,5 +59,6 @@
     "./src/Pnpm.js": false,
     "./src/Yarn.js": false
   },
-  "type": "commonjs"
-}
+  "type": "commonjs",
+  "gitHead": "5ad950d33a5f2255ebeb10c04a2e84c346e2de85"
+}

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

@@ -1,5 +1,3 @@
-// @flow strict-local
-
 import type {JSONObject} from '@atlaspack/types';
 
 import logger from '@atlaspack/logger';
@@ -8,21 +6,24 @@ import {Transform} from 'stream';
 // Transforms chunks of json strings to parsed objects.
 // Pair with split2 to parse stream of newline-delimited text.
 export default class JSONParseStream extends Transform {
-  constructor(options: mixed) {
+  constructor(options: unknown) {
+    // @ts-expect-error TS2698
     super({...options, objectMode: true});
   }
 
-  // $FlowFixMe We are in object mode, so we emit objects, not strings
   _transform(
     chunk: Buffer | string,
     encoding: string,
-    callback: (err: ?Error, parsed: ?JSONObject) => mixed,
+    callback: (
+      err?: Error | null | undefined,
+      parsed?: JSONObject | null | undefined,
+    ) => unknown,
   ) {
     try {
       let parsed;
       try {
         parsed = JSON.parse(chunk.toString());
-      } catch (e) {
+      } catch (e: any) {
         // Be permissive and ignoreJSON parse errors in case there was
         // a non-JSON line in the package manager's stdout.
         logger.verbose({
@@ -32,7 +33,7 @@ export default class JSONParseStream extends Transform {
         return;
       }
       callback(null, parsed);
-    } catch (err) {
+    } catch (err: any) {
       callback(err);
     }
   }

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

@@ -1,5 +1,3 @@
-// @flow
-
 import type {
   ModuleRequest,
   PackageInstaller,
@@ -14,10 +12,10 @@ import {ncp} from '@atlaspack/fs';
 import pkg from '../package.json';
 import {moduleRequestsFromDependencyMap} from './utils';
 
-type Package = {|
-  fs: FileSystem,
-  packagePath: FilePath,
-|};
+type Package = {
+  fs: FileSystem;
+  packagePath: FilePath;
+};
 
 // This PackageInstaller implementation simply copies files from one filesystem to another.
 // Mostly useful for testing purposes.

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

@@ -1,4 +1,3 @@
-// @flow
 import type {
   FilePath,
   DependencySpecifier,
@@ -62,25 +61,27 @@ 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>;
 
   constructor(
     fs: FileSystem,
     projectRoot: FilePath,
-    installer?: ?PackageInstaller,
+    installer?: PackageInstaller | null,
   ) {
     this.fs = fs;
     this.projectRoot = projectRoot;
     this.installer = installer;
 
-    // $FlowFixMe - no type for _extensions
+    // @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:
@@ -97,8 +98,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(
@@ -117,12 +118,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,
@@ -134,11 +135,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) {
@@ -155,10 +156,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);
@@ -172,20 +173,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
@@ -195,23 +195,23 @@ 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);
     };
 
@@ -222,35 +222,37 @@ export class NodePackageManager implements PackageManager {
           extname === '.tsx' ||
           extname === '.mts' ||
           extname === '.cts') &&
-        // $FlowFixMe
+        // @ts-expect-error TS2339
         !Module._extensions[extname]
       ) {
+        // @ts-expect-error TS2339
         let compile = m._compile;
-        m._compile = (code, filename) => {
+        // @ts-expect-error TS2339
+        m._compile = (code: any, filename: any) => {
           let out = transformSync(code, {filename, module: {type: 'commonjs'}});
           compile.call(m, out.code, filename);
         };
 
-        // $FlowFixMe
-        Module._extensions[extname] = (m, filename) => {
-          // $FlowFixMe
+        // @ts-expect-error TS2339
+        Module._extensions[extname] = (m: any, filename: any) => {
+          // @ts-expect-error TS2339
           delete Module._extensions[extname];
-          // $FlowFixMe
+          // @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;
     }
 
@@ -260,11 +262,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;
@@ -273,7 +275,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 ||
@@ -291,7 +293,7 @@ export class NodePackageManager implements PackageManager {
                 ],
               },
             });
-            // $FlowFixMe - needed for loadParcelPlugin
+            // @ts-expect-error TS2339
             err.code = 'MODULE_NOT_FOUND';
             throw err;
           } else {
@@ -320,6 +322,7 @@ 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: [
@@ -361,6 +364,7 @@ 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: [
@@ -383,8 +387,10 @@ 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}.`;
           }
 
@@ -474,7 +480,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)) {
@@ -487,6 +496,7 @@ export class NodePackageManager implements PackageManager {
           return;
         }
 
+        // @ts-expect-error TS2345
         res.invalidateOnFileCreate.push(...resolved.invalidateOnFileCreate);
         res.invalidateOnFileChange.add(resolved.resolved);
 
@@ -508,15 +518,19 @@ 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,
@@ -526,7 +540,9 @@ export class NodePackageManager implements PackageManager {
         }
       }
 
+      // @ts-expect-error TS2345
       invalidationsCache.set(resolved.resolved, res);
+      // @ts-expect-error TS2322
       return res;
     }
 
@@ -540,7 +556,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)) {
@@ -567,10 +586,10 @@ export class NodePackageManager implements PackageManager {
 
       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];
       }
 
@@ -604,17 +623,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':
@@ -636,6 +656,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);