@storybook/cli 6.4.0-beta.24 → 6.4.0-beta.25

package/dist/cjs/js-package-manager/JsPackageManager.js

@@ -0,0 +1,273 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getPackageDetails = getPackageDetails;
+exports.JsPackageManager = void 0;
+
+require("core-js/modules/es.promise.js");
+
+var _chalk = _interopRequireDefault(require("chalk"));
+
+var _semver = require("@storybook/semver");
+
+var _crossSpawn = require("cross-spawn");
+
+var _helpers = require("../helpers");
+
+var _PackageJsonHelper = require("./PackageJsonHelper");
+
+var _versions = _interopRequireDefault(require("../versions.json"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const logger = console;
+/**
+ * Extract package name and version from input
+ *
+ * @param pkg A string like `@storybook/cli`, `react` or `react@^16`
+ * @return A tuple of 2 elements: [packageName, packageVersion]
+ */
+
+function getPackageDetails(pkg) {
+  const idx = pkg.lastIndexOf('@'); // If the only `@` is the first character, it is a scoped package
+  // If it isn't in the string, it will be -1
+
+  if (idx <= 0) {
+    return [pkg, undefined];
+  }
+
+  const packageName = pkg.slice(0, idx);
+  const packageVersion = pkg.slice(idx + 1);
+  return [packageName, packageVersion];
+}
+
+class JsPackageManager {
+  constructor() {
+    this.type = void 0;
+  }
+
+  /**
+   * Install dependencies listed in `package.json`
+   */
+  installDependencies() {
+    let done = (0, _helpers.commandLog)('Preparing to install dependencies');
+    done();
+    logger.log();
+    logger.log();
+    done = (0, _helpers.commandLog)('Installing dependencies');
+
+    try {
+      this.runInstall();
+    } catch (e) {
+      done('An error occurred while installing dependencies.');
+      process.exit(1);
+    }
+
+    done();
+  }
+  /**
+   * Read the `package.json` file available in the directory the command was call from
+   * If there is no `package.json` it will create one.
+   */
+
+
+  retrievePackageJson() {
+    let packageJson = (0, _PackageJsonHelper.readPackageJson)();
+
+    if (!packageJson) {
+      // It will create a new package.json file
+      this.initPackageJson(); // read the newly created package.json file
+
+      packageJson = (0, _PackageJsonHelper.readPackageJson)() || {};
+    }
+
+    return Object.assign({}, packageJson, {
+      dependencies: Object.assign({}, packageJson.dependencies),
+      devDependencies: Object.assign({}, packageJson.devDependencies)
+    });
+  }
+  /**
+   * Add dependencies to a project using `yarn add` or `npm install`.
+   *
+   * @param {Object} options contains `skipInstall`, `packageJson` and `installAsDevDependencies` which we use to determine how we install packages.
+   * @param {Array} dependencies contains a list of packages to add.
+   * @example
+   * addDependencies(options, [
+   *   `@storybook/react@${storybookVersion}`,
+   *   `@storybook/addon-actions@${actionsVersion}`,
+   *   `@storybook/addon-links@${linksVersion}`,
+   *   `@storybook/addons@${addonsVersion}`,
+   * ]);
+   */
+
+
+  addDependencies(options, dependencies) {
+    const {
+      skipInstall
+    } = options;
+
+    if (skipInstall) {
+      const {
+        packageJson
+      } = options;
+      const dependenciesMap = dependencies.reduce((acc, dep) => {
+        const [packageName, packageVersion] = getPackageDetails(dep);
+        return Object.assign({}, acc, {
+          [packageName]: packageVersion
+        });
+      }, {});
+
+      if (options.installAsDevDependencies) {
+        packageJson.devDependencies = Object.assign({}, packageJson.devDependencies, dependenciesMap);
+      } else {
+        packageJson.dependencies = Object.assign({}, packageJson.dependencies, dependenciesMap);
+      }
+
+      (0, _PackageJsonHelper.writePackageJson)(packageJson);
+    } else {
+      try {
+        this.runAddDeps(dependencies, options.installAsDevDependencies);
+      } catch (e) {
+        logger.error('An error occurred while installing dependencies.');
+        logger.log(e.message);
+        process.exit(1);
+      }
+    }
+  }
+  /**
+   * Return an array of strings matching following format: `<package_name>@<package_latest_version>`
+   *
+   * @param packages
+   */
+
+
+  getVersionedPackages(...packages) {
+    return Promise.all(packages.map(async pkg => {
+      const [packageName, packageVersion] = getPackageDetails(pkg);
+      return `${packageName}@${await this.getVersion(packageName, packageVersion)}`;
+    }));
+  }
+  /**
+   * Return an array of string standing for the latest version of the input packages.
+   * To be able to identify which version goes with which package the order of the input array is keep.
+   *
+   * @param packageNames
+   */
+
+
+  getVersions(...packageNames) {
+    return Promise.all(packageNames.map(packageName => this.getVersion(packageName)));
+  }
+  /**
+   * Return the latest version of the input package available on npmjs registry.
+   * If constraint are provided it return the latest version matching the constraints.
+   *
+   * For `@storybook/*` packages the latest version is retrieved from `cli/src/versions.json` file directly
+   *
+   * @param packageName The name of the package
+   * @param constraint A valid semver constraint, example: '1.x || >=2.5.0 || 5.0.0 - 7.2.3'
+   */
+
+
+  async getVersion(packageName, constraint) {
+    let current;
+
+    if (/@storybook/.test(packageName)) {
+      // @ts-ignore
+      current = _versions.default[packageName];
+    }
+
+    let latest;
+
+    try {
+      latest = await this.latestVersion(packageName, constraint);
+    } catch (e) {
+      if (current) {
+        logger.warn(`\n     ${_chalk.default.yellow(e.message)}`);
+        return current;
+      }
+
+      logger.error(`\n     ${_chalk.default.red(e.message)}`);
+      process.exit(1);
+    }
+
+    const versionToUse = current && (!constraint || (0, _semver.satisfies)(current, constraint)) && (0, _semver.gt)(current, latest) ? current : latest;
+    return `^${versionToUse}`;
+  }
+  /**
+   * Get the latest version of the package available on npmjs.com.
+   * If constraint is set then it returns a version satisfying it, otherwise the latest version available is returned.
+   *
+   * @param packageName Name of the package
+   * @param constraint Version range to use to constraint the returned version
+   */
+
+
+  async latestVersion(packageName, constraint) {
+    if (!constraint) {
+      return this.runGetVersions(packageName, false);
+    }
+
+    const versions = await this.runGetVersions(packageName, true); // Get the latest version satisfying the constraint
+
+    return versions.reverse().find(version => (0, _semver.satisfies)(version, constraint));
+  }
+
+  addStorybookCommandInScripts(options) {
+    var _options$port;
+
+    const sbPort = (_options$port = options === null || options === void 0 ? void 0 : options.port) !== null && _options$port !== void 0 ? _options$port : 6006;
+    const storybookCmd = options !== null && options !== void 0 && options.staticFolder ? `start-storybook -p ${sbPort} -s ${options.staticFolder}` : `start-storybook -p ${sbPort}`;
+    const buildStorybookCmd = options !== null && options !== void 0 && options.staticFolder ? `build-storybook -s ${options.staticFolder}` : `build-storybook`;
+    const preCommand = options !== null && options !== void 0 && options.preCommand ? this.getRunCommand(options.preCommand) : undefined;
+    this.addScripts({
+      storybook: [preCommand, storybookCmd].filter(Boolean).join(' && '),
+      'build-storybook': [preCommand, buildStorybookCmd].filter(Boolean).join(' && ')
+    });
+  }
+
+  addESLintConfig() {
+    var _packageJson$eslintCo;
+
+    const packageJson = this.retrievePackageJson();
+    (0, _PackageJsonHelper.writePackageJson)(Object.assign({}, packageJson, {
+      eslintConfig: Object.assign({}, packageJson.eslintConfig, {
+        overrides: [...(((_packageJson$eslintCo = packageJson.eslintConfig) === null || _packageJson$eslintCo === void 0 ? void 0 : _packageJson$eslintCo.overrides) || []), {
+          files: ['**/*.stories.*'],
+          rules: {
+            'import/no-anonymous-default-export': 'off'
+          }
+        }]
+      })
+    }));
+  }
+
+  addScripts(scripts) {
+    const packageJson = this.retrievePackageJson();
+    (0, _PackageJsonHelper.writePackageJson)(Object.assign({}, packageJson, {
+      scripts: Object.assign({}, packageJson.scripts, scripts)
+    }));
+  }
+
+  executeCommand(command, args, stdio) {
+    var _commandResult$stdout;
+
+    const commandResult = (0, _crossSpawn.sync)(command, args, {
+      stdio: stdio !== null && stdio !== void 0 ? stdio : 'pipe',
+      encoding: 'utf-8'
+    });
+
+    if (commandResult.status !== 0) {
+      var _commandResult$stderr;
+
+      throw new Error((_commandResult$stderr = commandResult.stderr) !== null && _commandResult$stderr !== void 0 ? _commandResult$stderr : '');
+    }
+
+    return (_commandResult$stdout = commandResult.stdout) !== null && _commandResult$stdout !== void 0 ? _commandResult$stdout : '';
+  }
+
+}
+
+exports.JsPackageManager = JsPackageManager;

package/dist/cjs/js-package-manager/JsPackageManagerFactory.js

@@ -0,0 +1,57 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.JsPackageManagerFactory = void 0;
+
+var _crossSpawn = require("cross-spawn");
+
+var _findUp = require("find-up");
+
+var _NPMProxy = require("./NPMProxy");
+
+var _Yarn2Proxy = require("./Yarn2Proxy");
+
+var _Yarn1Proxy = require("./Yarn1Proxy");
+
+class JsPackageManagerFactory {
+  static getPackageManager(forceNpmUsage = false) {
+    if (forceNpmUsage) {
+      return new _NPMProxy.NPMProxy();
+    }
+
+    const yarnVersion = getYarnVersion();
+    const hasYarnLockFile = (0, _findUp.sync)('yarn.lock');
+    const hasNPMCommand = hasNPM();
+
+    if (yarnVersion && (hasYarnLockFile || !hasNPMCommand)) {
+      return yarnVersion === 1 ? new _Yarn1Proxy.Yarn1Proxy() : new _Yarn2Proxy.Yarn2Proxy();
+    }
+
+    if (hasNPMCommand) {
+      return new _NPMProxy.NPMProxy();
+    }
+
+    throw new Error('Unable to find a usable package manager within NPM, Yarn and Yarn 2');
+  }
+
+}
+
+exports.JsPackageManagerFactory = JsPackageManagerFactory;
+
+function hasNPM() {
+  const npmVersionCommand = (0, _crossSpawn.sync)('npm', ['--version']);
+  return npmVersionCommand.status === 0;
+}
+
+function getYarnVersion() {
+  const yarnVersionCommand = (0, _crossSpawn.sync)('yarn', ['--version']);
+
+  if (yarnVersionCommand.status !== 0) {
+    return undefined;
+  }
+
+  const yarnVersion = yarnVersionCommand.output.toString().replace(/,/g, '').replace(/"/g, '');
+  return /^1\.+/.test(yarnVersion) ? 1 : 2;
+}

package/dist/cjs/js-package-manager/NPMProxy.js

@@ -0,0 +1,76 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.NPMProxy = void 0;
+
+var _semver = _interopRequireDefault(require("@storybook/semver"));
+
+var _JsPackageManager = require("./JsPackageManager");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+class NPMProxy extends _JsPackageManager.JsPackageManager {
+  constructor(...args) {
+    super(...args);
+    this.type = 'npm';
+    this.installArgs = void 0;
+  }
+
+  initPackageJson() {
+    return this.executeCommand('npm', ['init', '-y']);
+  }
+
+  getRunStorybookCommand() {
+    return 'npm run storybook';
+  }
+
+  getRunCommand(command) {
+    return `npm run ${command}`;
+  }
+
+  getInstallArgs() {
+    if (!this.installArgs) {
+      const version = this.executeCommand('npm', ['--version']);
+      this.installArgs = _semver.default.gte(version, '7.0.0') ? ['install', '--legacy-peer-deps'] : ['install'];
+    }
+
+    return this.installArgs;
+  }
+
+  runInstall() {
+    this.executeCommand('npm', this.getInstallArgs(), 'inherit');
+  }
+
+  runAddDeps(dependencies, installAsDevDependencies) {
+    let args = [...dependencies];
+
+    if (installAsDevDependencies) {
+      args = ['-D', ...args];
+    }
+
+    this.executeCommand('npm', [...this.getInstallArgs(), ...args], 'inherit');
+  }
+
+  runGetVersions(packageName, fetchAllVersions) {
+    const args = [fetchAllVersions ? 'versions' : 'version', '--json'];
+    const commandResult = this.executeCommand('npm', ['info', packageName, ...args]);
+
+    try {
+      const parsedOutput = JSON.parse(commandResult);
+
+      if (parsedOutput.error) {
+        // FIXME: improve error handling
+        throw new Error(parsedOutput.error.summary);
+      } else {
+        return parsedOutput;
+      }
+    } catch (e) {
+      throw new Error(`Unable to find versions of ${packageName} using npm`);
+    }
+  }
+
+}
+
+exports.NPMProxy = NPMProxy;

package/dist/cjs/js-package-manager/PackageJson.js

@@ -0,0 +1 @@
+"use strict";

package/dist/cjs/js-package-manager/PackageJsonHelper.js

@@ -0,0 +1,33 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.readPackageJson = readPackageJson;
+exports.writePackageJson = writePackageJson;
+
+var _path = _interopRequireDefault(require("path"));
+
+var _fs = _interopRequireDefault(require("fs"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function readPackageJson() {
+  const packageJsonPath = _path.default.resolve('package.json');
+
+  if (!_fs.default.existsSync(packageJsonPath)) {
+    return false;
+  }
+
+  const jsonContent = _fs.default.readFileSync(packageJsonPath, 'utf8');
+
+  return JSON.parse(jsonContent);
+}
+
+function writePackageJson(packageJson) {
+  const content = `${JSON.stringify(packageJson, null, 2)}\n`;
+
+  const packageJsonPath = _path.default.resolve('package.json');
+
+  _fs.default.writeFileSync(packageJsonPath, content, 'utf8');
+}

package/dist/cjs/js-package-manager/Yarn1Proxy.js

@@ -0,0 +1,61 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Yarn1Proxy = void 0;
+
+var _JsPackageManager = require("./JsPackageManager");
+
+class Yarn1Proxy extends _JsPackageManager.JsPackageManager {
+  constructor(...args) {
+    super(...args);
+    this.type = 'yarn1';
+  }
+
+  initPackageJson() {
+    return this.executeCommand('yarn', ['init', '-y']);
+  }
+
+  getRunStorybookCommand() {
+    return 'yarn storybook';
+  }
+
+  getRunCommand(command) {
+    return `yarn ${command}`;
+  }
+
+  runInstall() {
+    this.executeCommand('yarn', [], 'inherit');
+  }
+
+  runAddDeps(dependencies, installAsDevDependencies) {
+    let args = ['--ignore-workspace-root-check', ...dependencies];
+
+    if (installAsDevDependencies) {
+      args = ['-D', ...args];
+    }
+
+    this.executeCommand('yarn', ['add', ...args], 'inherit');
+  }
+
+  runGetVersions(packageName, fetchAllVersions) {
+    const args = [fetchAllVersions ? 'versions' : 'version', '--json'];
+    const commandResult = this.executeCommand('yarn', ['info', packageName, ...args]);
+
+    try {
+      const parsedOutput = JSON.parse(commandResult);
+
+      if (parsedOutput.type === 'inspect') {
+        return parsedOutput.data;
+      }
+
+      throw new Error(`Unable to find versions of ${packageName} using yarn`);
+    } catch (e) {
+      throw new Error(`Unable to find versions of ${packageName} using yarn`);
+    }
+  }
+
+}
+
+exports.Yarn1Proxy = Yarn1Proxy;

package/dist/cjs/js-package-manager/Yarn2Proxy.js

@@ -0,0 +1,57 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Yarn2Proxy = void 0;
+
+var _JsPackageManager = require("./JsPackageManager");
+
+class Yarn2Proxy extends _JsPackageManager.JsPackageManager {
+  constructor(...args) {
+    super(...args);
+    this.type = 'yarn2';
+  }
+
+  initPackageJson() {
+    return this.executeCommand('yarn', ['init']);
+  }
+
+  getRunStorybookCommand() {
+    return 'yarn storybook';
+  }
+
+  getRunCommand(command) {
+    return `yarn ${command}`;
+  }
+
+  runInstall() {
+    this.executeCommand('yarn', [], 'inherit');
+  }
+
+  runAddDeps(dependencies, installAsDevDependencies) {
+    let args = [...dependencies];
+
+    if (installAsDevDependencies) {
+      args = ['-D', ...args];
+    }
+
+    this.executeCommand('yarn', ['add', ...args], 'inherit');
+  }
+
+  runGetVersions(packageName, fetchAllVersions) {
+    const field = fetchAllVersions ? 'versions' : 'version';
+    const args = ['--fields', field, '--json'];
+    const commandResult = this.executeCommand('yarn', ['npm', 'info', packageName, ...args]);
+
+    try {
+      const parsedOutput = JSON.parse(commandResult);
+      return parsedOutput[field];
+    } catch (e) {
+      throw new Error(`Unable to find versions of ${packageName} using yarn 2`);
+    }
+  }
+
+}
+
+exports.Yarn2Proxy = Yarn2Proxy;

package/dist/cjs/js-package-manager/index.js

@@ -0,0 +1,57 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _JsPackageManagerFactory = require("./JsPackageManagerFactory");
+
+Object.keys(_JsPackageManagerFactory).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _JsPackageManagerFactory[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _JsPackageManagerFactory[key];
+    }
+  });
+});
+
+var _JsPackageManager = require("./JsPackageManager");
+
+Object.keys(_JsPackageManager).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _JsPackageManager[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _JsPackageManager[key];
+    }
+  });
+});
+
+var _PackageJson = require("./PackageJson");
+
+Object.keys(_PackageJson).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _PackageJson[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _PackageJson[key];
+    }
+  });
+});
+
+var _PackageJsonHelper = require("./PackageJsonHelper");
+
+Object.keys(_PackageJsonHelper).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _PackageJsonHelper[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _PackageJsonHelper[key];
+    }
+  });
+});