@ohos-ports/parcel-package-manager 2.16.4-beta.0

package/src/Npm.js

@@ -0,0 +1,94 @@
+// @flow strict-local
+
+import type {PackageInstaller, InstallerOptions} from '@parcel/types';
+
+import path from 'path';
+import spawn from 'cross-spawn';
+import logger from '@parcel/logger';
+import promiseFromProcess from './promiseFromProcess';
+import {registerSerializableClass} from '@parcel/core';
+import {npmSpecifierFromModuleRequest} from './utils';
+
+// $FlowFixMe
+import pkg from '../package.json';
+
+const NPM_CMD = 'npm';
+
+export class Npm implements PackageInstaller {
+  async install({
+    modules,
+    cwd,
+    fs,
+    packagePath,
+    saveDev = true,
+  }: InstallerOptions): Promise<void> {
+    // npm doesn't auto-create a package.json when installing,
+    // so create an empty one if needed.
+    if (packagePath == null) {
+      await fs.writeFile(path.join(cwd, 'package.json'), '{}');
+    }
+
+    let args = ['install', '--json', saveDev ? '--save-dev' : '--save'].concat(
+      modules.map(npmSpecifierFromModuleRequest),
+    );
+
+    // 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 = {};
+    for (let key in process.env) {
+      if (!key.startsWith('npm_') && key !== 'INIT_CWD' && key !== 'NODE_ENV') {
+        env[key] = process.env[key];
+      }
+    }
+
+    let installProcess = spawn(NPM_CMD, args, {cwd, env});
+    let stdout = '';
+    installProcess.stdout.on('data', (buf: Buffer) => {
+      stdout += buf.toString();
+    });
+
+    let stderr = [];
+    installProcess.stderr.on('data', (buf: Buffer) => {
+      stderr.push(buf.toString().trim());
+    });
+
+    try {
+      await promiseFromProcess(installProcess);
+
+      let results: NPMResults = JSON.parse(stdout);
+      let addedCount = results.added.length;
+      if (addedCount > 0) {
+        logger.log({
+          origin: '@parcel/package-manager',
+          message: `Added ${addedCount} packages via npm`,
+        });
+      }
+
+      // Since we succeeded, stderr might have useful information not included
+      // in the json written to stdout. It's also not necessary to log these as
+      // errors as they often aren't.
+      for (let message of stderr) {
+        if (message.length > 0) {
+          logger.log({
+            origin: '@parcel/package-manager',
+            message,
+          });
+        }
+      }
+    } catch (e) {
+      throw new Error(
+        'npm failed to install modules: ' +
+          e.message +
+          ' - ' +
+          stderr.join('\n'),
+      );
+    }
+  }
+}
+
+type NPMResults = {|
+  added: Array<{name: string, ...}>,
+|};
+
+registerSerializableClass(`${pkg.version}:Npm`, Npm);

package/src/Pnpm.js

@@ -0,0 +1,194 @@
+// @flow strict-local
+
+import type {PackageInstaller, InstallerOptions} from '@parcel/types';
+
+import path from 'path';
+import fs from 'fs';
+import commandExists from 'command-exists';
+import spawn from 'cross-spawn';
+import logger from '@parcel/logger';
+import split from 'split2';
+import JSONParseStream from './JSONParseStream';
+import promiseFromProcess from './promiseFromProcess';
+import {registerSerializableClass} from '@parcel/core';
+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 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;
+
+export class Pnpm implements PackageInstaller {
+  static async exists(): Promise<boolean> {
+    if (hasPnpm != null) {
+      return hasPnpm;
+    }
+
+    try {
+      hasPnpm = Boolean(await commandExists('pnpm'));
+    } catch (err) {
+      hasPnpm = false;
+    }
+
+    return hasPnpm;
+  }
+
+  async install({
+    modules,
+    cwd,
+    saveDev = true,
+  }: InstallerOptions): Promise<void> {
+    if (pnpmVersion == null) {
+      let version = await exec('pnpm --version');
+      pnpmVersion = parseInt(version.stdout, 10);
+    }
+
+    let args = ['add', '--reporter', 'ndjson'];
+    if (saveDev) {
+      args.push('-D');
+    }
+    if (pnpmVersion >= 7) {
+      if (fs.existsSync(path.join(cwd, 'pnpm-workspace.yaml'))) {
+        // installs in workspace root (regardless of cwd)
+        args.push('-w');
+      }
+    } else {
+      // ignores workspace root check
+      args.push('-W');
+    }
+    args = args.concat(modules.map(npmSpecifierFromModuleRequest));
+
+    let env = {};
+    for (let key in process.env) {
+      if (!key.startsWith('npm_') && key !== 'INIT_CWD' && key !== 'NODE_ENV') {
+        env[key] = process.env[key];
+      }
+    }
+
+    let addedCount = 0,
+      removedCount = 0;
+
+    let installProcess = spawn(PNPM_CMD, args, {
+      cwd,
+      env,
+    });
+    installProcess.stdout
+      .pipe(split())
+      .pipe(new JSONParseStream())
+      .on('error', e => {
+        logger.warn({
+          origin: '@parcel/package-manager',
+          message: e.chunk,
+          stack: e.stack,
+        });
+      })
+      .on('data', (json: PNPMResults) => {
+        if (json.level === 'error') {
+          logger.error({
+            origin: '@parcel/package-manager',
+            message: json.err.message,
+            stack: json.err.stack,
+          });
+        } else if (json.level === 'info' && typeof json.message === 'string') {
+          logger.info({
+            origin: '@parcel/package-manager',
+            message: prefix(json.message),
+          });
+        } else if (json.name === 'pnpm:stats') {
+          addedCount += json.added ?? 0;
+          removedCount += json.removed ?? 0;
+        }
+      });
+
+    let stderr = [];
+    installProcess.stderr
+      .on('data', str => {
+        stderr.push(str.toString());
+      })
+      .on('error', e => {
+        logger.warn({
+          origin: '@parcel/package-manager',
+          message: e.message,
+        });
+      });
+
+    try {
+      await promiseFromProcess(installProcess);
+
+      if (addedCount > 0 || removedCount > 0) {
+        logger.log({
+          origin: '@parcel/package-manager',
+          message: `Added ${addedCount} ${
+            removedCount > 0 ? `and removed ${removedCount} ` : ''
+          }packages via pnpm`,
+        });
+      }
+
+      // Since we succeeded, stderr might have useful information not included
+      // in the json written to stdout. It's also not necessary to log these as
+      // errors as they often aren't.
+      for (let message of stderr) {
+        logger.log({
+          origin: '@parcel/package-manager',
+          message,
+        });
+      }
+    } catch (e) {
+      throw new Error('pnpm failed to install modules');
+    }
+  }
+}
+
+function prefix(message: string): string {
+  return 'pnpm: ' + message;
+}
+
+registerSerializableClass(`${pkg.version}:Pnpm`, Pnpm);

package/src/Yarn.js

@@ -0,0 +1,157 @@
+// @flow strict-local
+
+import type {PackageInstaller, InstallerOptions} from '@parcel/types';
+
+import commandExists from 'command-exists';
+import spawn from 'cross-spawn';
+import logger from '@parcel/logger';
+import split from 'split2';
+import JSONParseStream from './JSONParseStream';
+import promiseFromProcess from './promiseFromProcess';
+import {registerSerializableClass} from '@parcel/core';
+import {exec, npmSpecifierFromModuleRequest} from './utils';
+
+// $FlowFixMe
+import pkg from '../package.json';
+
+const YARN_CMD = 'yarn';
+
+type YarnStdOutMessage =
+  | {|
+      +type: 'step',
+      data: {|
+        message: string,
+        current: number,
+        total: number,
+      |},
+    |}
+  | {|+type: 'success', data: string|}
+  | {|+type: 'info', data: string|}
+  | {|+type: 'tree' | 'progressStart' | 'progressTick'|};
+
+type YarnStdErrMessage = {|
+  +type: 'error' | 'warning',
+  data: string,
+|};
+
+let hasYarn: ?boolean;
+let yarnVersion: ?number;
+
+export class Yarn implements PackageInstaller {
+  static async exists(): Promise<boolean> {
+    if (hasYarn != null) {
+      return hasYarn;
+    }
+
+    try {
+      hasYarn = Boolean(await commandExists('yarn'));
+    } catch (err) {
+      hasYarn = false;
+    }
+
+    return hasYarn;
+  }
+
+  async install({
+    modules,
+    cwd,
+    saveDev = true,
+  }: InstallerOptions): Promise<void> {
+    if (yarnVersion == null) {
+      let version = await exec('yarn --version');
+      yarnVersion = parseInt(version.stdout, 10);
+    }
+
+    let args = ['add', '--json'].concat(
+      modules.map(npmSpecifierFromModuleRequest),
+    );
+
+    if (saveDev) {
+      args.push('-D');
+      if (yarnVersion < 2) {
+        args.push('-W');
+      }
+    }
+
+    // When Parcel is run by Yarn (e.g. via package.json scripts), several environment variables are
+    // added. When parcel in turn calls Yarn again, these can cause Yarn to behave stragely, so we
+    // filter them out when installing packages.
+    let env = {};
+    for (let key in process.env) {
+      if (
+        !key.startsWith('npm_') &&
+        key !== 'YARN_WRAP_OUTPUT' &&
+        key !== 'INIT_CWD' &&
+        key !== 'NODE_ENV'
+      ) {
+        env[key] = process.env[key];
+      }
+    }
+
+    let installProcess = spawn(YARN_CMD, args, {cwd, env});
+    installProcess.stdout
+      // Invoking yarn with --json provides streaming, newline-delimited JSON output.
+      .pipe(split())
+      .pipe(new JSONParseStream())
+      .on('error', e => {
+        logger.error(e, '@parcel/package-manager');
+      })
+      .on('data', (message: YarnStdOutMessage) => {
+        switch (message.type) {
+          case 'step':
+            logger.progress(
+              prefix(
+                `[${message.data.current}/${message.data.total}] ${message.data.message}`,
+              ),
+            );
+            return;
+          case 'success':
+          case 'info':
+            logger.info({
+              origin: '@parcel/package-manager',
+              message: prefix(message.data),
+            });
+            return;
+          default:
+          // ignore
+        }
+      });
+
+    installProcess.stderr
+      .pipe(split())
+      .pipe(new JSONParseStream())
+      .on('error', e => {
+        logger.error(e, '@parcel/package-manager');
+      })
+      .on('data', (message: YarnStdErrMessage) => {
+        switch (message.type) {
+          case 'warning':
+            logger.warn({
+              origin: '@parcel/package-manager',
+              message: prefix(message.data),
+            });
+            return;
+          case 'error':
+            logger.error({
+              origin: '@parcel/package-manager',
+              message: prefix(message.data),
+            });
+            return;
+          default:
+          // ignore
+        }
+      });
+
+    try {
+      return await promiseFromProcess(installProcess);
+    } catch (e) {
+      throw new Error('Yarn failed to install modules:' + e.message);
+    }
+  }
+}
+
+function prefix(message: string): string {
+  return 'yarn: ' + message;
+}
+
+registerSerializableClass(`${pkg.version}:Yarn`, Yarn);

package/src/getCurrentPackageManager.js

@@ -0,0 +1,17 @@
+// @flow
+
+export default function getCurrentPackageManager(
+  userAgent: ?string = process.env.npm_config_user_agent,
+): ?{|name: string, version: string|} {
+  if (!userAgent) {
+    return undefined;
+  }
+
+  const pmSpec = userAgent.split(' ')[0];
+  const separatorPos = pmSpec.lastIndexOf('/');
+  const name = pmSpec.substring(0, separatorPos);
+  return {
+    name: name,
+    version: pmSpec.substring(separatorPos + 1),
+  };
+}

package/src/index.js

@@ -0,0 +1,19 @@
+// @flow
+
+import type {PackageManagerResolveResult} from '@parcel/types';
+
+export type {
+  PackageManager,
+  Invalidations,
+  PackageInstaller,
+  ModuleRequest,
+} from '@parcel/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};