@carbon/cli 10.29.0

package/src/commands/bundle/javascript.js

@@ -0,0 +1,142 @@
+/**
+ * Copyright IBM Corp. 2018, 2018
+ *
+ * This source code is licensed under the Apache-2.0 license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+'use strict';
+
+const { babel } = require('@rollup/plugin-babel');
+const commonjs = require('@rollup/plugin-commonjs');
+const { nodeResolve } = require('@rollup/plugin-node-resolve');
+const { pascalCase } = require('change-case');
+const fs = require('fs-extra');
+const path = require('path');
+const { rollup } = require('rollup');
+
+async function bundle(entrypoint, options) {
+  const globals = options.globals ? formatGlobals(options.globals) : {};
+  const { name } = options;
+  const packageFolder = await findPackageFolder(entrypoint);
+
+  const outputFolders = [
+    {
+      format: 'esm',
+      directory: path.join(packageFolder, 'es'),
+    },
+    {
+      format: 'cjs',
+      directory: path.join(packageFolder, 'lib'),
+    },
+    {
+      format: 'umd',
+      directory: path.join(packageFolder, 'umd'),
+    },
+  ];
+
+  await Promise.all(outputFolders.map(({ directory }) => fs.remove(directory)));
+
+  const jsEntryPoints = outputFolders.map(({ directory, format }) => ({
+    file: path.join(directory, 'index.js'),
+    format,
+  }));
+
+  const packageJsonPath = path.join(packageFolder, 'package.json');
+  const packageJson = await fs.readJson(packageJsonPath);
+  const { dependencies = {} } = packageJson;
+
+  const bundle = await rollup({
+    input: entrypoint,
+    external: Object.keys(dependencies),
+    plugins: [
+      babel({
+        exclude: 'node_modules/**',
+        babelrc: false,
+        presets: [
+          [
+            '@babel/preset-env',
+            {
+              modules: false,
+              targets: {
+                browsers: ['last 1 version', 'ie >= 11', 'Firefox ESR'],
+              },
+            },
+          ],
+        ],
+        babelHelpers: 'bundled',
+      }),
+      nodeResolve(),
+      commonjs({
+        include: [/node_modules/],
+        extensions: ['.js'],
+      }),
+    ],
+  });
+
+  await Promise.all(
+    jsEntryPoints.map(({ format, file }) => {
+      const outputOptions = {
+        format,
+        file,
+        exports: 'auto',
+      };
+
+      if (format === 'umd') {
+        outputOptions.name = name;
+        outputOptions.globals = {
+          ...formatDependenciesIntoGlobals(dependencies),
+          ...globals,
+        };
+      }
+
+      return bundle.write(outputOptions);
+    })
+  );
+}
+
+function formatGlobals(string) {
+  const mappings = string.split(',').map((mapping) => {
+    return mapping.split('=');
+  });
+  return mappings.reduce(
+    (acc, [pkg, global]) => ({
+      ...acc,
+      [pkg]: global,
+    }),
+    {}
+  );
+}
+
+function formatDependenciesIntoGlobals(dependencies) {
+  return Object.keys(dependencies).reduce((acc, key) => {
+    const parts = key.split('/').map((identifier, i) => {
+      if (i === 0) {
+        return identifier.replace(/@/, '');
+      }
+      return identifier;
+    });
+
+    return {
+      ...acc,
+      [key]: pascalCase(parts.join(' ')),
+    };
+  }, {});
+}
+
+async function findPackageFolder(entrypoint) {
+  let packageFolder = entrypoint;
+
+  while (packageFolder !== '/' && path.dirname(packageFolder) !== '/') {
+    packageFolder = path.dirname(packageFolder);
+    const packageJsonPath = path.join(packageFolder, 'package.json');
+
+    if (await fs.pathExists(packageJsonPath)) {
+      break;
+    }
+  }
+
+  return packageFolder;
+}
+
+module.exports = bundle;

package/src/commands/bundle.js

@@ -0,0 +1,67 @@
+/**
+ * Copyright IBM Corp. 2019, 2019
+ *
+ * This source code is licensed under the Apache-2.0 license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+'use strict';
+
+const path = require('path');
+const { createLogger } = require('../logger');
+const bundlers = require('./bundle/bundlers');
+
+const logger = createLogger('bundle');
+
+async function bundle({ entrypoint, name, globals }) {
+  logger.start('bundle');
+
+  const cwd = process.cwd();
+  const extension = path.extname(entrypoint);
+
+  if (!bundlers.has(extension)) {
+    logger.info(
+      `Invalid extension: \`${extension}\` on entrypoint: \`${entrypoint}\``
+    );
+    process.exit(1);
+  }
+
+  try {
+    const bundle = bundlers.get(extension);
+    await bundle(path.join(cwd, entrypoint), {
+      name,
+      globals,
+    });
+  } catch (error) {
+    logger.info(`Unexpected error occurred while bundling ${entrypoint}:`);
+    console.log(error);
+    process.exit(1);
+  }
+
+  logger.stop();
+}
+
+module.exports = {
+  command: 'bundle <entrypoint>',
+  desc: 'bundle the given .js entrypoint',
+  builder(yargs) {
+    yargs.positional('entrypoint', {
+      type: 'string',
+      describe: 'the entrypoint Javascript file',
+    });
+
+    yargs.options({
+      n: {
+        alias: 'name',
+        describe: 'the name of the module for the UMD build',
+        type: 'string',
+      },
+      g: {
+        alias: 'globals',
+        describe: 'global module names',
+        type: 'string',
+      },
+    });
+  },
+  handler: bundle,
+};

package/src/commands/changelog.js

@@ -0,0 +1,70 @@
+/**
+ * Copyright IBM Corp. 2019, 2019
+ *
+ * This source code is licensed under the Apache-2.0 license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+'use strict';
+
+const clipboard = require('clipboardy');
+const { prompt } = require('inquirer');
+const { generate } = require('../changelog');
+const { fetchLatestFromUpstream } = require('../git');
+const { createLogger, displayBanner } = require('../logger');
+const { getPackages } = require('../workspace');
+
+const logger = createLogger('changelog');
+
+/**
+ * Outputs a changelog for the list of packages in a lerna/yarn workspace for
+ * the given tag range. You can specify the range of commits to get the
+ * changelog for by using git tags, or the name of a branch. For example:
+ * v10.5.1..master or v10.5.0..v10.5.1
+ * @returns {void}
+ */
+async function changelog({ range }) {
+  displayBanner();
+
+  logger.start('Fetching latest git information from upstream');
+  await fetchLatestFromUpstream();
+  logger.stop();
+
+  logger.start('Getting a list of all packages in the project');
+  const packages = await getPackages();
+  logger.stop();
+
+  const [lastTag, tag] = range.split('..');
+  logger.start(`Generating a changelog for range: ${range}`);
+  const changelog = await generate(packages, lastTag, tag);
+  logger.stop();
+
+  const { copy } = await prompt([
+    {
+      type: 'confirm',
+      name: 'copy',
+      message: 'Would you like to copy the changelog to your clipboard?',
+    },
+  ]);
+
+  if (copy) {
+    clipboard.writeSync(changelog);
+    // eslint-disable-next-line no-console
+    console.log('Done!');
+  } else {
+    // eslint-disable-next-line no-console
+    console.log(changelog);
+  }
+}
+
+module.exports = {
+  command: 'changelog <range>',
+  desc: 'generate the changelog for the given git tag range',
+  builder(yargs) {
+    yargs.positional('range', {
+      describe: 'the git tag range to generate a changelog for',
+      type: 'string',
+    });
+  },
+  handler: changelog,
+};

package/src/commands/check.js

@@ -0,0 +1,71 @@
+/**
+ * Copyright IBM Corp. 2019, 2019
+ *
+ * This source code is licensed under the Apache-2.0 license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+'use strict';
+
+const glob = require('fast-glob');
+const path = require('path');
+const { createLogger } = require('../logger');
+const compile = require('../compile');
+
+const logger = createLogger('check');
+
+async function check({ glob: pattern, ignore = [], list = false }) {
+  const cwd = process.cwd();
+
+  logger.start('check');
+  logger.info(`Running in: ${cwd}`);
+  logger.info(`Checking pattern: '${pattern}', ignoring: '${ignore}'`);
+
+  const files = await glob(pattern, {
+    cwd,
+    ignore,
+  });
+
+  logger.info(`Compiling ${files.length} files...`);
+
+  try {
+    compile(files.map((file) => path.join(cwd, file)));
+
+    if (list) {
+      logger.info('Compiled the following files:');
+      console.log(files);
+    }
+
+    logger.info(`Successfully compiled ${files.length} files! 🎉`);
+  } catch (error) {
+    console.log(error);
+    process.exit(1);
+  } finally {
+    logger.stop();
+  }
+}
+
+module.exports = {
+  command: 'check <glob>',
+  desc: 'check that each file can be compiled',
+  builder(yargs) {
+    yargs.positional('glob', {
+      type: 'string',
+      describe: 'glob pattern for files to check',
+    });
+
+    yargs.options({
+      i: {
+        alias: 'ignore',
+        describe: 'provide a glob pattern of files to ignore',
+        type: 'string',
+      },
+      l: {
+        alias: 'list',
+        describe: 'list all the files that were compiled',
+        type: 'boolean',
+      },
+    });
+  },
+  handler: check,
+};

package/src/commands/ci-check.js

@@ -0,0 +1,51 @@
+/**
+ * Copyright IBM Corp. 2019, 2019
+ *
+ * This source code is licensed under the Apache-2.0 license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+/* eslint-disable no-console */
+
+'use strict';
+
+const { reporter } = require('@carbon/cli-reporter');
+const { exec } = require('child-process-promise');
+const { workspace } = require('../workspace');
+
+async function check(args, env) {
+  reporter.info('Running checks in CI...');
+
+  const options = {
+    cwd: env.root.directory,
+    stdio: 'inherit',
+  };
+  const tasks = [
+    `yarn carbon-cli check --ignore '**/@(node_modules|examples|components|react|fixtures|compat)/**' 'packages/**/*.scss'`,
+    `cross-env BABEL_ENV=test yarn test --ci --maxWorkers 2 --reporters=default --reporters=jest-junit`,
+    `cross-env BABEL_ENV=test yarn test:e2e --ci --maxWorkers 2 --reporters=default --reporters=jest-junit`,
+    `cross-env PERCY_TOKEN=dd3392142006a6483c8f524697f39f052755fa9dc087ff4437cac3d64227abdd yarn run percy exec -- yarn workspace carbon-components-react test:e2e`,
+  ];
+
+  try {
+    for (const task of tasks) {
+      const now = Date.now();
+
+      reporter.info(`Running: ${task}`);
+      await exec(task, options);
+      reporter.success(`Done in: ${Date.now() - now}ms`);
+    }
+  } catch (error) {
+    console.log(error.stdout);
+    console.log(error.stderr);
+    console.log(error);
+    process.exit(1);
+  }
+}
+
+module.exports = {
+  command: 'ci-check',
+  desc: 'run CI checks',
+  builder: {},
+  handler: workspace(check),
+};

package/src/commands/component.js

@@ -0,0 +1,130 @@
+/**
+ * Copyright IBM Corp. 2019, 2019
+ *
+ * This source code is licensed under the Apache-2.0 license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+'use strict';
+
+const { paramCase } = require('change-case');
+const fs = require('fs-extra');
+const { prompt } = require('enquirer');
+const path = require('path');
+const { loadTemplates } = require('../component');
+const { createLogger } = require('../logger');
+
+const logger = createLogger('component');
+
+function clearConsole() {
+  process.stdout.write(
+    process.platform === 'win32' ? '\x1B[2J\x1B[0f' : '\x1B[2J\x1B[3J\x1B[H'
+  );
+}
+
+async function component() {
+  const templates = await loadTemplates();
+  const questions = [
+    {
+      type: 'input',
+      name: 'name',
+      message: 'What is the name of this component?',
+      validate(value) {
+        if (value === '') {
+          return 'A name is required for the component';
+        }
+        return true;
+      },
+    },
+    {
+      type: 'input',
+      name: 'directory',
+      message: 'Specify the path for this component',
+      initial: '.',
+    },
+    {
+      type: 'multiselect',
+      name: 'options',
+      message: 'What else should we scaffold out for you?',
+      initial: ['tests', 'stories'],
+      choices: [
+        {
+          name: 'tests',
+          value: true,
+        },
+        {
+          name: 'stories',
+          value: true,
+        },
+      ],
+      result(names) {
+        return this.map(names);
+      },
+    },
+  ];
+
+  clearConsole();
+  const answers = await prompt(questions);
+
+  logger.start('Generating component...');
+
+  const directory = path.resolve(
+    process.cwd(),
+    answers.directory,
+    answers.name
+  );
+
+  logger.info(`Writing component directory to ${directory}`);
+
+  if (await fs.exists(directory)) {
+    throw new Error(`A directory already exists at ${directory}`);
+  }
+
+  logger.info('Scaffolding out default files...');
+
+  await fs.ensureDir(directory);
+  await fs.writeFile(
+    path.join(directory, 'index.js'),
+    templates.index.compile({ name: answers.name })
+  );
+  await fs.writeFile(
+    path.join(directory, `${answers.name}.js`),
+    templates.component.compile({ name: answers.name })
+  );
+
+  if (answers.options.tests) {
+    logger.start('Scaffolding out test files...');
+    await fs.ensureDir(path.join(directory, '__tests__'));
+    await fs.writeFile(
+      path.join(directory, '__tests__', `${answers.name}-test.js`),
+      templates.test.compile({ name: answers.name })
+    );
+    logger.stop();
+  }
+
+  if (answers.options.stories) {
+    logger.start('Scaffolding out story files...');
+    await fs.writeFile(
+      path.join(directory, `${answers.name}-story.js`),
+      templates.story.compile({
+        name: answers.name,
+      })
+    );
+    await fs.writeFile(
+      path.join(directory, `${answers.name}.mdx`),
+      templates.mdx.compile({
+        name: answers.name,
+        url: paramCase(answers.name),
+      })
+    );
+    logger.stop();
+  }
+
+  logger.stop();
+}
+
+module.exports = {
+  command: 'component',
+  desc: '[EXPERIMENTAL] Scaffold a component in React',
+  handler: component,
+};