@atlaspack/package-manager 2.14.5-canary.16 → 2.14.5-canary.161

package/lib/installPackage.js

@@ -0,0 +1,222 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports._addToInstallQueue = _addToInstallQueue;
+exports.installPackage = installPackage;
+function _assert() {
+  const data = _interopRequireDefault(require("assert"));
+  _assert = function () {
+    return data;
+  };
+  return data;
+}
+function _path() {
+  const data = _interopRequireDefault(require("path"));
+  _path = function () {
+    return data;
+  };
+  return data;
+}
+function _nullthrows() {
+  const data = _interopRequireDefault(require("nullthrows"));
+  _nullthrows = function () {
+    return data;
+  };
+  return data;
+}
+function _semver() {
+  const data = _interopRequireDefault(require("semver"));
+  _semver = function () {
+    return data;
+  };
+  return data;
+}
+function _diagnostic() {
+  const data = _interopRequireWildcard(require("@atlaspack/diagnostic"));
+  _diagnostic = function () {
+    return data;
+  };
+  return data;
+}
+function _logger() {
+  const data = _interopRequireDefault(require("@atlaspack/logger"));
+  _logger = function () {
+    return data;
+  };
+  return data;
+}
+function _utils() {
+  const data = require("@atlaspack/utils");
+  _utils = function () {
+    return data;
+  };
+  return data;
+}
+function _workers() {
+  const data = _interopRequireDefault(require("@atlaspack/workers"));
+  _workers = function () {
+    return data;
+  };
+  return data;
+}
+var _Npm = require("./Npm");
+var _Yarn = require("./Yarn");
+var _Pnpm = require("./Pnpm");
+var _utils2 = require("./utils");
+var _getCurrentPackageManager = _interopRequireDefault(require("./getCurrentPackageManager"));
+var _validateModuleSpecifier = _interopRequireDefault(require("./validateModuleSpecifier"));
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+async function install(fs, packageManager, modules, from, projectRoot, options = {}) {
+  let {
+    installPeers = true,
+    saveDev = true,
+    packageInstaller
+  } = options;
+  let moduleNames = modules.map(m => m.name).join(', ');
+  _logger().default.progress(`Installing ${moduleNames}...`);
+  let fromPkgPath = await (0, _utils().resolveConfig)(fs, from, ['package.json'], projectRoot);
+  let cwd = fromPkgPath ? _path().default.dirname(fromPkgPath) : fs.cwd();
+  if (!packageInstaller) {
+    packageInstaller = await determinePackageInstaller(fs, from, projectRoot);
+  }
+  try {
+    await packageInstaller.install({
+      modules,
+      saveDev,
+      cwd,
+      packagePath: fromPkgPath,
+      fs
+    });
+  } catch (err) {
+    throw new Error(`Failed to install ${moduleNames}: ${err.message}`);
+  }
+  if (installPeers) {
+    await Promise.all(modules.map(m => installPeerDependencies(fs, packageManager, m, from, projectRoot, options)));
+  }
+}
+async function installPeerDependencies(fs, packageManager, module, from, projectRoot, options) {
+  const {
+    resolved
+  } = await packageManager.resolve(module.name, from);
+  const modulePkg = (0, _nullthrows().default)(await (0, _utils().loadConfig)(fs, resolved, ['package.json'], projectRoot)).config;
+  const peers = modulePkg.peerDependencies || {};
+  let modules = [];
+  for (let [name, range] of Object.entries(peers)) {
+    (0, _assert().default)(typeof range === 'string');
+    let conflicts = await (0, _utils2.getConflictingLocalDependencies)(fs, name, from, projectRoot);
+    if (conflicts) {
+      let {
+        pkg
+      } = await packageManager.resolve(name, from);
+      (0, _assert().default)(pkg);
+      if (!_semver().default.satisfies(pkg.version, range)) {
+        throw new (_diagnostic().default)({
+          diagnostic: {
+            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: [{
+              filePath: conflicts.filePath,
+              language: 'json',
+              code: conflicts.json,
+              codeHighlights: (0, _diagnostic().generateJSONCodeHighlights)(conflicts.json, conflicts.fields.map(field => ({
+                key: `/${field}/${(0, _diagnostic().encodeJSONKeyComponent)(name)}`,
+                type: 'key',
+                message: 'Found this conflicting local requirement.'
+              })))
+            }]
+          }
+        });
+      }
+      continue;
+    }
+    modules.push({
+      name,
+      range
+    });
+  }
+  if (modules.length) {
+    await install(fs, packageManager, modules, from, projectRoot, Object.assign({}, options, {
+      installPeers: false
+    }));
+  }
+}
+async function determinePackageInstaller(fs, filepath, projectRoot) {
+  var _getCurrentPackageMan;
+  let configFile = await (0, _utils().resolveConfig)(fs, filepath, ['package-lock.json', 'pnpm-lock.yaml', 'yarn.lock'], projectRoot);
+  let configName = configFile && _path().default.basename(configFile);
+
+  // Always use the package manager that seems to be used in the project,
+  // falling back to a different one wouldn't update the existing lockfile.
+  if (configName === 'package-lock.json') {
+    return new _Npm.Npm();
+  } else if (configName === 'pnpm-lock.yaml') {
+    return new _Pnpm.Pnpm();
+  } else if (configName === 'yarn.lock') {
+    return new _Yarn.Yarn();
+  }
+  let currentPackageManager = (_getCurrentPackageMan = (0, _getCurrentPackageManager.default)()) === null || _getCurrentPackageMan === void 0 ? void 0 : _getCurrentPackageMan.name;
+  if (currentPackageManager === 'npm') {
+    return new _Npm.Npm();
+  } else if (currentPackageManager === 'yarn') {
+    return new _Yarn.Yarn();
+  } else if (currentPackageManager === 'pnpm') {
+    return new _Pnpm.Pnpm();
+  }
+  if (await _Yarn.Yarn.exists()) {
+    return new _Yarn.Yarn();
+  } else if (await _Pnpm.Pnpm.exists()) {
+    return new _Pnpm.Pnpm();
+  } else {
+    return new _Npm.Npm();
+  }
+}
+let queue = new (_utils().PromiseQueue)({
+  maxConcurrent: 1
+});
+let modulesInstalling = new Set();
+
+// Exported so that it may be invoked from the worker api below.
+// Do not call this directly! This can result in concurrent package installations
+// across multiple instances of the package manager.
+function _addToInstallQueue(fs, packageManager, modules, filePath, projectRoot, options) {
+  modules = modules.map(request => ({
+    name: (0, _validateModuleSpecifier.default)(request.name),
+    range: request.range
+  }));
+
+  // Wrap PromiseQueue and track modules that are currently installing.
+  // If a request comes in for a module that is currently installing, don't bother
+  // enqueuing it.
+  let modulesToInstall = modules.filter(m => !modulesInstalling.has(getModuleRequestKey(m)));
+  if (modulesToInstall.length) {
+    for (let m of modulesToInstall) {
+      modulesInstalling.add(getModuleRequestKey(m));
+    }
+    queue.add(() => install(fs, packageManager, modulesToInstall, filePath, projectRoot, options).then(() => {
+      for (let m of modulesToInstall) {
+        modulesInstalling.delete(getModuleRequestKey(m));
+      }
+    }));
+  }
+  return queue.run();
+}
+function installPackage(fs, packageManager, modules, filePath, projectRoot, options) {
+  if (_workers().default.isWorker()) {
+    let workerApi = _workers().default.getWorkerApi();
+    // TODO this should really be `__filename` but without the rewriting.
+    let bundlePath = process.env.ATLASPACK_BUILD_ENV === 'production' && !process.env.ATLASPACK_SELF_BUILD ? _path().default.join(__dirname, '..', 'lib/index.js') : __filename;
+    return workerApi.callMaster({
+      location: bundlePath,
+      args: [fs, packageManager, modules, filePath, projectRoot, options],
+      method: '_addToInstallQueue'
+    });
+  }
+  return _addToInstallQueue(fs, packageManager, modules, filePath, projectRoot, options);
+}
+function getModuleRequestKey(moduleRequest) {
+  return [moduleRequest.name, moduleRequest.range].join('@');
+}

package/lib/nodejsConditions.js

@@ -0,0 +1,41 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.defaultNodejsConditions = void 0;
+exports.getConditionsFromEnv = getConditionsFromEnv;
+function _process() {
+  const data = _interopRequireDefault(require("process"));
+  _process = function () {
+    return data;
+  };
+  return data;
+}
+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']);
+let envConditions = undefined;
+
+/** @description Gets the export conditions from NODE_OPTIONS and node arguments */
+function getConditionsFromEnv() {
+  if (!envConditions) {
+    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.js

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = promiseFromProcess;
+function promiseFromProcess(childProcess) {
+  return new Promise((resolve, reject) => {
+    childProcess.on('error', reject);
+    childProcess.on('close', code => {
+      if (code !== 0) {
+        reject(new Error('Child process failed'));
+        return;
+      }
+
+      // @ts-expect-error TS2794
+      resolve();
+    });
+  });
+}

package/lib/types/JSONParseStream.d.ts

@@ -0,0 +1,6 @@
+import type { JSONObject } from '@atlaspack/types';
+import { Transform } from 'stream';
+export default class JSONParseStream extends Transform {
+    constructor(options: unknown);
+    _transform(chunk: Buffer | string, encoding: string, callback: (err?: Error | null | undefined, parsed?: JSONObject | null | undefined) => unknown): void;
+}

package/lib/types/MockPackageInstaller.d.ts

@@ -0,0 +1,14 @@
+import type { ModuleRequest, PackageInstaller, InstallerOptions } from '@atlaspack/types';
+import type { FileSystem } from '@atlaspack/fs';
+import type { FilePath } from '@atlaspack/types';
+type Package = {
+    fs: FileSystem;
+    packagePath: FilePath;
+};
+export declare class MockPackageInstaller implements PackageInstaller {
+    packages: Map<string, Package>;
+    register(packageName: string, fs: FileSystem, packagePath: FilePath): void;
+    install({ modules, fs, cwd, packagePath, saveDev, }: InstallerOptions): Promise<void>;
+    installPackage(moduleRequest: ModuleRequest, fs: FileSystem, packagePath: FilePath): Promise<any>;
+}
+export {};

package/lib/types/NodePackageManager.d.ts

@@ -0,0 +1,36 @@
+import type { FilePath, DependencySpecifier, SemverRange } from '@atlaspack/types';
+import type { FileSystem } from '@atlaspack/fs';
+import type { ModuleRequest, PackageManager, PackageInstaller, InstallOptions, Invalidations, PackageManagerResolveResult } from '@atlaspack/types';
+export declare class NodePackageManager implements PackageManager {
+    fs: FileSystem;
+    projectRoot: FilePath;
+    installer: PackageInstaller | null | undefined;
+    resolver: ResolverBase;
+    currentExtensions: Array<string>;
+    constructor(fs: FileSystem, projectRoot: FilePath, installer?: PackageInstaller | null);
+    _createResolver(): ResolverBase;
+    static deserialize(opts: any): NodePackageManager;
+    serialize(): {
+        $$raw: boolean;
+        fs: FileSystem;
+        projectRoot: FilePath;
+        installer: PackageInstaller | null | undefined;
+    };
+    require(name: DependencySpecifier, from: FilePath, opts?: {
+        range?: SemverRange | null | undefined;
+        shouldAutoInstall?: boolean;
+        saveDev?: boolean;
+    } | null): Promise<any>;
+    requireSync(name: DependencySpecifier, from: FilePath): any;
+    load(filePath: FilePath, from: FilePath): any;
+    resolve(id: DependencySpecifier, from: FilePath, options?: {
+        range?: SemverRange | null | undefined;
+        shouldAutoInstall?: boolean;
+        saveDev?: boolean;
+    } | null): Promise<PackageManagerResolveResult>;
+    resolveSync(name: DependencySpecifier, from: FilePath): PackageManagerResolveResult;
+    install(modules: Array<ModuleRequest>, from: FilePath, opts?: InstallOptions): Promise<void>;
+    getInvalidations(name: DependencySpecifier, from: FilePath): Invalidations;
+    invalidate(name: DependencySpecifier, from: FilePath): void;
+    resolveInternal(name: string, from: string): PackageManagerResolveResult;
+}

package/lib/types/Npm.d.ts

@@ -0,0 +1,4 @@
+import type { PackageInstaller, InstallerOptions } from '@atlaspack/types';
+export declare class Npm implements PackageInstaller {
+    install({ modules, cwd, fs, packagePath, saveDev, }: InstallerOptions): Promise<void>;
+}

package/lib/types/Pnpm.d.ts

@@ -0,0 +1,5 @@
+import type { PackageInstaller, InstallerOptions } from '@atlaspack/types';
+export declare class Pnpm implements PackageInstaller {
+    static exists(): Promise<boolean>;
+    install({ modules, cwd, saveDev, }: InstallerOptions): Promise<void>;
+}

package/lib/types/Yarn.d.ts

@@ -0,0 +1,5 @@
+import type { PackageInstaller, InstallerOptions } from '@atlaspack/types';
+export declare class Yarn implements PackageInstaller {
+    static exists(): Promise<boolean>;
+    install({ modules, cwd, saveDev, }: InstallerOptions): Promise<void>;
+}

package/lib/types/getCurrentPackageManager.d.ts

@@ -0,0 +1,4 @@
+export default function getCurrentPackageManager(userAgent?: string | null): {
+    name: string;
+    version: string;
+} | null | undefined;

package/lib/types/index.d.ts

@@ -0,0 +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';
+export type { PackageManagerResolveResult };
+export type { PackageManagerResolveResult as ResolveResult };

package/lib/types/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/types/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/types/promiseFromProcess.d.ts

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

package/lib/types/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/types/validateModuleSpecifier.d.ts

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

package/lib/utils.js

@@ -0,0 +1,101 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.exec = void 0;
+exports.getConflictingLocalDependencies = getConflictingLocalDependencies;
+exports.moduleRequestsFromDependencyMap = moduleRequestsFromDependencyMap;
+exports.npmSpecifierFromModuleRequest = npmSpecifierFromModuleRequest;
+function _assert() {
+  const data = _interopRequireDefault(require("assert"));
+  _assert = function () {
+    return data;
+  };
+  return data;
+}
+function _diagnostic() {
+  const data = _interopRequireDefault(require("@atlaspack/diagnostic"));
+  _diagnostic = function () {
+    return data;
+  };
+  return data;
+}
+function _utils() {
+  const data = require("@atlaspack/utils");
+  _utils = function () {
+    return data;
+  };
+  return data;
+}
+function _child_process() {
+  const data = require("child_process");
+  _child_process = function () {
+    return data;
+  };
+  return data;
+}
+function _util() {
+  const data = require("util");
+  _util = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const exec = exports.exec = _child_process().exec ? (0, _util().promisify)(_child_process().exec) :
+// _exec is undefined in browser builds
+_child_process().exec;
+function npmSpecifierFromModuleRequest(moduleRequest) {
+  return moduleRequest.range != null ? [moduleRequest.name, moduleRequest.range].join('@') : moduleRequest.name;
+}
+function moduleRequestsFromDependencyMap(dependencyMap) {
+  return Object.entries(dependencyMap).map(([name, range]) => {
+    (0, _assert().default)(typeof range === 'string');
+    return {
+      name,
+      range
+    };
+  });
+}
+async function getConflictingLocalDependencies(fs, name, local, projectRoot) {
+  let pkgPath = await (0, _utils().resolveConfig)(fs, local, ['package.json'], projectRoot);
+  if (pkgPath == null) {
+    return;
+  }
+  let pkgStr = await fs.readFile(pkgPath, 'utf8');
+  let pkg;
+  try {
+    pkg = JSON.parse(pkgStr);
+  } catch (e) {
+    // TODO: codeframe
+    throw new (_diagnostic().default)({
+      diagnostic: {
+        message: 'Failed to parse package.json',
+        origin: '@atlaspack/package-manager'
+      }
+    });
+  }
+  if (typeof pkg !== 'object' || pkg == null) {
+    // TODO: codeframe
+    throw new (_diagnostic().default)({
+      diagnostic: {
+        message: 'Expected package.json contents to be an object.',
+        origin: '@atlaspack/package-manager'
+      }
+    });
+  }
+  let fields = [];
+  for (let field of ['dependencies', 'devDependencies', 'peerDependencies']) {
+    if (typeof pkg[field] === 'object' && pkg[field] != null && pkg[field][name] != null) {
+      fields.push(field);
+    }
+  }
+  if (fields.length > 0) {
+    return {
+      filePath: pkgPath,
+      json: pkgStr,
+      fields
+    };
+  }
+}

package/lib/validateModuleSpecifier.js

@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = validateModuleSpecifier;
+const MODULE_REGEX = /^((@[^/\s]+\/){0,1}([^/\s.~]+[^/\s]*)){1}(@[^/\s]+){0,1}/;
+function validateModuleSpecifier(moduleName) {
+  let matches = MODULE_REGEX.exec(moduleName);
+  if (matches) {
+    return matches[0];
+  }
+  return '';
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaspack/package-manager",
-  "version": "2.14.5-canary.16+4b2b575b9",
+  "version": "2.14.5-canary.161+ee040bb64",
   "description": "Blazing fast, zero configuration web application bundler",
   "license": "(MIT OR Apache-2.0)",
   "publishConfig": {
@@ -10,16 +10,16 @@
     "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/types/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",
-    "test": "mocha test"
+    "check-ts": "tsc --emitDeclarationOnly --rootDir src",
+    "test": "mocha test",
+    "build:lib": "gulp build --gulpfile ../../../gulpfile.js --cwd ."
   },
   "targets": {
     "types": false,
@@ -39,21 +39,19 @@
     }
   },
   "dependencies": {
-    "@atlaspack/build-cache": "2.13.3-canary.84+4b2b575b9",
-    "@atlaspack/diagnostic": "2.14.1-canary.84+4b2b575b9",
-    "@atlaspack/fs": "2.14.5-canary.16+4b2b575b9",
-    "@atlaspack/logger": "2.14.5-canary.16+4b2b575b9",
-    "@atlaspack/node-resolver-core": "3.5.5-canary.16+4b2b575b9",
-    "@atlaspack/types": "2.14.5-canary.16+4b2b575b9",
-    "@atlaspack/utils": "2.14.5-canary.16+4b2b575b9",
-    "@atlaspack/workers": "2.14.5-canary.16+4b2b575b9",
+    "@atlaspack/build-cache": "2.13.3-canary.229+ee040bb64",
+    "@atlaspack/diagnostic": "2.14.1-canary.229+ee040bb64",
+    "@atlaspack/fs": "2.14.5-canary.161+ee040bb64",
+    "@atlaspack/logger": "2.14.5-canary.161+ee040bb64",
+    "@atlaspack/node-resolver-core": "3.5.5-canary.161+ee040bb64",
+    "@atlaspack/types": "2.14.5-canary.161+ee040bb64",
+    "@atlaspack/utils": "2.14.5-canary.161+ee040bb64",
+    "@atlaspack/workers": "2.14.5-canary.161+ee040bb64",
     "@swc/core": "^1.10.0",
-    "semver": "^7.5.2"
-  },
-  "devDependencies": {
     "command-exists": "^1.2.6",
     "cross-spawn": "^6.0.4",
     "nullthrows": "^1.1.1",
+    "semver": "^7.5.2",
     "split2": "^3.1.1"
   },
   "browser": {
@@ -63,5 +61,5 @@
     "./src/Yarn.js": false
   },
   "type": "commonjs",
-  "gitHead": "4b2b575b98951f2dcf0c45ed8e94359b23b43815"
+  "gitHead": "ee040bb6428f29b57d892ddd8107e29077d08ffd"
 }

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.