release-it 15.0.0-esm.0 → 15.0.0-esm.4

package/README.md

@@ -156,19 +156,18 @@ remote.
 
 ## GitHub Releases
 
-The "Releases" tab on GitHub projects links to a page to store the changelog cq. release notes. To add
+GitHub projects can have releases attached to Git tags, containing release notes and assets. There are two ways to add
 [GitHub releases](https://help.github.com/articles/creating-releases) in your release-it flow:
 
-- Configure `github.release: true`
-- Obtain a [personal access token](https://github.com/settings/tokens/new?scopes=repo&description=release-it)
-  (release-it only needs "repo" access; no "admin" or other scopes).
-- Make sure the token is [available as an environment variable](./docs/environment-variables.md).
+1. Automated (requires a `GITHUB_TOKEN`)
+2. Manual (using the GitHub web interface with pre-populated fields)
 
 → See [GitHub Releases](./docs/github-releases.md) for more details.
 
 ## GitLab Releases
 
-[GitLab releases](https://docs.gitlab.com/ce/user/project/releases/) work just like GitHub releases:
+GitLab projects can have releases attached to Git tags, containing release notes and assets. To automate
+[GitLab releases](https://docs.gitlab.com/ce/user/project/releases/):
 
 - Configure `gitlab.release: true`
 - Obtain a [personal access token](https://gitlab.com/profile/personal_access_tokens) (release-it only needs the "api"
@@ -210,11 +209,11 @@ pre-releases. An example pre-release version is `2.0.0-beta.0`.
 
 ## Update or re-run existing releases
 
-Use `--no-increment` to not increment the lastest version and update an existing tag/version.
+Use `--no-increment` to not increment the last version, but update the last existing tag/version.
 
-This may be helpful in some cases where the version was already incremented. Here's a few example scenarios:
+This may be helpful in cases where the version was already incremented. Here's a few example scenarios:
 
-- To update or publish a draft GitHub Release for an existing Git tag.
+- To update or publish a (draft) GitHub Release for an existing Git tag.
 - Publishing to npm succeeded, but pushing the Git tag to the remote failed. Then use
   `release-it --no-increment --no-npm` to skip the `npm publish` and try pushing the same Git tag again.
 
@@ -322,17 +321,18 @@ While mostly used as a CLI tool, release-it can be used as a dependency to integ
 - [blockchain/blockchain-wallet-v4-frontend](https://github.com/blockchain/blockchain-wallet-v4-frontend)
 - [callstack/linaria](https://github.com/callstack/linaria)
 - [ember-cli/ember-cli](https://github.com/ember-cli/ember-cli)
-  [react-native-paper](https://github.com/callstack/react-native-paper)
+- [metalsmith/metalsmith](https://github.com/metalsmith/metalsmith)
+- [react-native-paper](https://github.com/callstack/react-native-paper)
 - [js-cookie/js-cookie](https://github.com/js-cookie/js-cookie)
 - [mirumee/saleor](https://github.com/mirumee/saleor)
 - [mozilla/readability](https://github.com/mozilla/readability)
-- [satya164/react-native-tab-view](https://github.com/satya164/react-native-tab-view)
+- [redis/node-redis](https://github.com/redis/node-redis)
 - [shipshapecode/shepherd](https://github.com/shipshapecode/shepherd)
 - [swagger-api/swagger-ui](https://github.com/swagger-api/swagger-ui) +
   [swagger-editor](https://github.com/swagger-api/swagger-editor)
 - [StevenBlack/hosts](https://github.com/StevenBlack/hosts)
-- [tabler](https://github.com/tabler/tabler) + [tabler-icons](https://github.com/tabler/tabler-icons)
-- [youzan/vant](https://github.com/youzan/vant/search?q=release-it)
+- [tabler/tabler](https://github.com/tabler/tabler) + [tabler-icons](https://github.com/tabler/tabler-icons)
+- [youzan/vant](https://github.com/youzan/vant)
 - [Repositories that depend on release-it](https://github.com/release-it/release-it/network/dependents)
 - GitHub search for [filename:.release-it.json](https://github.com/search?q=filename%3A.release-it.json)
 

package/bin/release-it.js

@@ -2,7 +2,7 @@
 
 import updater from 'update-notifier';
 import parseArgs from 'yargs-parser';
-import release from '../lib/index.js';
+import release from '../lib/cli.js';
 import { readJSON } from '../lib/util.js';
 
 const pkg = readJSON(new URL('../package.json', import.meta.url));

package/config/release-it.json

@@ -12,6 +12,7 @@
     "commitArgs": [],
     "tag": true,
     "tagName": null,
+    "tagMatch": null,
     "tagAnnotation": "Release ${version}",
     "tagArgs": [],
     "push": true,
@@ -32,6 +33,7 @@
     "release": false,
     "releaseName": "Release ${version}",
     "releaseNotes": null,
+    "autoGenerate": false,
     "preRelease": false,
     "draft": false,
     "tokenRef": "GITHUB_TOKEN",
@@ -39,7 +41,8 @@
     "host": null,
     "timeout": 0,
     "proxy": null,
-    "skipChecks": false
+    "skipChecks": false,
+    "web": false
   },
   "gitlab": {
     "release": false,

package/lib/cli.js

@@ -1,5 +1,6 @@
-import { readJSON } from '../lib/util.js';
+import { readJSON } from './util.js';
 import Log from './log.js';
+import runTasks from './index.js';
 
 const pkg = readJSON(new URL('../package.json', import.meta.url));
 
@@ -27,3 +28,14 @@ For more details, please see https://github.com/release-it/release-it`;
 export let version = () => log.log(`v${pkg.version}`);
 
 export let help = () => log.log(helpText);
+
+export default async options => {
+  if (options.version) {
+    version();
+  } else if (options.help) {
+    help();
+  } else {
+    return runTasks(options);
+  }
+  return Promise.resolve();
+};

package/lib/config.js

@@ -54,7 +54,6 @@ class Config {
 
   expandPreReleaseShorthand(options) {
     const { increment, preRelease, preReleaseId } = options;
-    options.isUpdate = increment === false;
     options.version = {
       increment,
       isPreRelease: Boolean(preRelease),
@@ -97,8 +96,8 @@ class Config {
     return Boolean(this.options['dry-run']);
   }
 
-  get isUpdate() {
-    return this.options.increment === false;
+  get isIncrement() {
+    return this.options.increment !== false;
   }
 
   get isVerbose() {

package/lib/index.js

@@ -1,16 +1,142 @@
-import { version, help } from './cli.js';
-import runTasks from './tasks.js';
+import _ from 'lodash';
+import { getPlugins } from './plugin/factory.js';
+import Logger from './log.js';
+import Config from './config.js';
+import Shell from './shell.js';
+import Prompt from './prompt.js';
+import Spinner from './spinner.js';
+import Metrics from './metrics.js';
+import { reduceUntil, parseVersion } from './util.js';
+import handleDeprecated from './deprecated.js';
 import Plugin from './plugin/Plugin.js';
 
-export default async options => {
-  if (options.version) {
-    version();
-  } else if (options.help) {
-    help();
-  } else {
-    return runTasks(options);
+const runTasks = async (opts, di) => {
+  let container = {};
+
+  try {
+    Object.assign(container, di);
+    container.config = container.config || new Config(opts);
+
+    const { config } = container;
+    const { isCI, isVerbose, verbosityLevel, isDryRun } = config;
+
+    container.log = container.log || new Logger({ isCI, isVerbose, verbosityLevel, isDryRun });
+    container.spinner = container.spinner || new Spinner({ container, config });
+    container.prompt = container.prompt || new Prompt({ container: { config } });
+    container.metrics = new Metrics({ isEnabled: config.isCollectMetrics });
+    container.shell = container.shell || new Shell({ container });
+
+    const { log, metrics, shell, spinner } = container;
+
+    const options = handleDeprecated(config.getContext(), log);
+
+    metrics.trackEvent('start', options);
+
+    const { hooks } = options;
+
+    const runHook = async (...name) => {
+      const scripts = hooks[name.join(':')];
+      if (!scripts || !scripts.length) return;
+      const context = config.getContext();
+      const external = true;
+      for (const script of _.castArray(scripts)) {
+        const task = () => shell.exec(script, { external }, context);
+        await spinner.show({ task, label: script, context, external });
+      }
+    };
+
+    const runLifeCycleHook = async (plugin, name, ...args) => {
+      if (plugin === _.first(plugins)) await runHook('before', name);
+      await runHook('before', plugin.namespace, name);
+      const willHookRun = (await plugin[name](...args)) !== false;
+      if (willHookRun) {
+        await runHook('after', plugin.namespace, name);
+      }
+      if (plugin === _.last(plugins)) await runHook('after', name);
+    };
+
+    const [internal, external] = await getPlugins(config, container);
+    let plugins = [...external, ...internal];
+
+    for (const plugin of plugins) {
+      await runLifeCycleHook(plugin, 'init');
+    }
+
+    const { increment, isPreRelease, preReleaseId } = options.version;
+
+    const name = await reduceUntil(plugins, plugin => plugin.getName());
+    const latestVersion = (await reduceUntil(plugins, plugin => plugin.getLatestVersion())) || '0.0.0';
+    const changelog = await reduceUntil(plugins, plugin => plugin.getChangelog(latestVersion));
+
+    const incrementBase = { latestVersion, increment, isPreRelease, preReleaseId };
+
+    let version;
+    if (config.isIncrement) {
+      incrementBase.increment = await reduceUntil(plugins, plugin => plugin.getIncrement(incrementBase));
+      version = await reduceUntil(plugins, plugin => plugin.getIncrementedVersionCI(incrementBase));
+    } else {
+      version = latestVersion;
+    }
+
+    if (config.isReleaseVersion) {
+      log.log(version);
+      process.exit(0);
+    }
+
+    config.setContext({ name, latestVersion, version, changelog });
+
+    const action = config.isIncrement ? 'release' : 'update';
+    const suffix = version && config.isIncrement ? `${latestVersion}...${version}` : `currently at ${latestVersion}`;
+
+    log.obtrusive(`🚀 Let's ${action} ${name} (${suffix})`);
+
+    log.preview({ title: 'changelog', text: changelog });
+
+    if (config.isIncrement) {
+      version = version || (await reduceUntil(plugins, plugin => plugin.getIncrementedVersion(incrementBase)));
+    }
+
+    config.setContext(parseVersion(version));
+
+    if (config.isPromptOnlyVersion) {
+      config.setCI(true);
+    }
+
+    for (const hook of ['beforeBump', 'bump', 'beforeRelease']) {
+      for (const plugin of plugins) {
+        const args = hook === 'bump' ? [version] : [];
+        await runLifeCycleHook(plugin, hook, ...args);
+      }
+    }
+
+    plugins = [...internal, ...external];
+
+    for (const hook of ['release', 'afterRelease']) {
+      for (const plugin of plugins) {
+        await runLifeCycleHook(plugin, hook);
+      }
+    }
+
+    await metrics.trackEvent('end');
+
+    log.log(`🏁 Done (in ${Math.floor(process.uptime())}s.)`);
+
+    return {
+      name,
+      changelog,
+      latestVersion,
+      version
+    };
+  } catch (err) {
+    const { log, metrics } = container;
+    if (metrics) {
+      await metrics.trackException(err);
+    }
+    log ? log.error(err.message || err) : console.error(err); // eslint-disable-line no-console
+    throw err;
   }
-  return Promise.resolve();
 };
 
+export default runTasks;
+
 export { Plugin };

package/lib/plugin/GitBase.js

@@ -10,11 +10,11 @@ class GitBase extends Plugin {
     this.remoteUrl = await this.getRemoteUrl();
     await this.fetch();
     const repo = parseGitUrl(this.remoteUrl);
-    const latestTagName = await this.getLatestTagName(repo);
-    const secondLatestTagName = this.config.isUpdate ? await this.getSecondLatestTagName(latestTagName) : null;
-    const tagTemplate = this.options.tagName || ((latestTagName || '').match(/^v/) ? 'v${version}' : '${version}');
-    this.setContext({ repo, tagTemplate, latestTagName, secondLatestTagName });
-    this.config.setContext({ latestTag: latestTagName });
+    const latestTag = await this.getLatestTagName(repo);
+    const secondLatestTag = !this.config.isIncrement ? await this.getSecondLatestTagName(latestTag) : null;
+    const tagTemplate = this.options.tagName || ((latestTag || '').match(/^v/) ? 'v${version}' : '${version}');
+    this.setContext({ repo });
+    this.config.setContext({ tagTemplate, latestTag, secondLatestTag });
   }
 
   getName() {
@@ -22,19 +22,20 @@ class GitBase extends Plugin {
   }
 
   getLatestVersion() {
-    const latestTagName = this.getContext('latestTagName');
-    return latestTagName ? latestTagName.replace(/^v/, '') : null;
+    const { tagTemplate, latestTag } = this.config.getContext();
+    const prefix = tagTemplate.replace(/\$\{version\}/, '');
+    return latestTag ? latestTag.replace(prefix, '').replace(/^v/, '') : null;
   }
 
   async getChangelog() {
-    const { isUpdate, latestTagName, secondLatestTagName } = this.getContext();
-    const context = { latestTag: latestTagName, from: latestTagName, to: 'HEAD' };
+    const { latestTag, secondLatestTag } = this.config.getContext();
+    const context = { latestTag, from: latestTag, to: 'HEAD' };
     const { changelog } = this.options;
     if (!changelog) return null;
 
-    if (latestTagName && isUpdate) {
-      context.from = secondLatestTagName;
-      context.to = `${latestTagName}^1`;
+    if (latestTag && !this.config.isIncrement) {
+      context.from = secondLatestTag;
+      context.to = `${latestTag}^1`;
     }
 
     if (!context.from && changelog.includes('${from}')) {
@@ -45,10 +46,10 @@ class GitBase extends Plugin {
   }
 
   bump(version) {
-    const { tagTemplate } = this.getContext();
+    const { tagTemplate } = this.config.getContext();
     const context = Object.assign(this.config.getContext(), { version });
     const tagName = format(tagTemplate, context) || version;
-    this.setContext({ version, tagName });
+    this.setContext({ version });
     this.config.setContext({ tagName });
   }
 
@@ -87,7 +88,7 @@ class GitBase extends Plugin {
 
   getLatestTagName(repo) {
     const context = Object.assign({ repo }, this.getContext(), { version: '*' });
-    const match = format(this.options.tagName || '${version}', context);
+    const match = format(this.options.tagMatch || this.options.tagName || '${version}', context);
     return this.exec(`git describe --tags --match=${match} --abbrev=0`, { options }).then(
       stdout => stdout || null,
       () => null
@@ -98,7 +99,7 @@ class GitBase extends Plugin {
     const sha = await this.exec(`git rev-list ${latestTag || '--skip=1'} --tags --max-count=1`, {
       options
     });
-    return this.exec(`git describe --tags --abbrev=0 ${sha}`, { options }).catch(() => null);
+    return this.exec(`git describe --tags --abbrev=0 "${sha}^"`, { options }).catch(() => null);
   }
 }
 

package/lib/plugin/factory.js

@@ -1,3 +1,4 @@
+import url from 'url';
 import path from 'path';
 import { createRequire } from 'module';
 import _ from 'lodash';
@@ -8,8 +9,6 @@ import GitLab from './gitlab/GitLab.js';
 import GitHub from './github/GitHub.js';
 import npm from './npm/npm.js';
 
-const require = createRequire(import.meta.url);
-
 const debug = _debug('release-it:plugins');
 
 const pluginNames = ['npm', 'git', 'github', 'gitlab', 'version'];
@@ -25,11 +24,18 @@ const plugins = {
 const load = async pluginName => {
   let plugin = null;
   try {
-    const module = await import(require.resolve(pluginName));
+    const module = await import(pluginName);
     plugin = module.default;
   } catch (err) {
-    const module = await import(require.resolve(path.resolve(pluginName)));
-    plugin = module.default;
+    try {
+      const module = await import(path.join(process.cwd(), pluginName));
+      plugin = module.default;
+    } catch (err) {
+      // In some cases or tests we might need to support legacy `require.resolve`
+      const require = createRequire(process.cwd());
+      const module = await import(url.pathToFileURL(require.resolve(pluginName, { paths: [process.cwd()] })));
+      plugin = module.default;
+    }
   }
   return [path.parse(pluginName).name, plugin];
 };

package/lib/plugin/git/Git.js

@@ -1,6 +1,6 @@
 import { EOL } from 'os';
 import _ from 'lodash';
-import findUp from 'find-up';
+import { execa } from 'execa';
 import { format, e } from '../../util.js';
 import GitBase from '../GitBase.js';
 import prompts from './prompts.js';
@@ -12,6 +12,12 @@ const fixArgs = args => (args ? (typeof args === 'string' ? args.split(' ') : ar
 
 const docs = 'https://git.io/release-it-git';
 
+const isGitRepo = () =>
+  execa('git', ['rev-parse', '--git-dir']).then(
+    () => true,
+    () => false
+  );
+
 class Git extends GitBase {
   constructor(...args) {
     super(...args);
@@ -19,7 +25,7 @@ class Git extends GitBase {
   }
 
   static async isEnabled(options) {
-    return options !== false && (await findUp('.git', { type: 'directory' }));
+    return options !== false && (await isGitRepo());
   }
 
   async init() {
@@ -46,7 +52,8 @@ class Git extends GitBase {
 
   rollback() {
     this.log.info('Rolling back changes...');
-    const { isCommitted, isTagged, tagName } = this.getContext();
+    const { tagName } = this.config.getContext();
+    const { isCommitted, isTagged } = this.getContext();
     if (isTagged) {
       this.exec(`git tag --delete ${tagName}`);
     }
@@ -175,12 +182,12 @@ class Git extends GitBase {
 
   tag({ name, annotation = this.options.tagAnnotation, args = this.options.tagArgs } = {}) {
     const message = format(annotation, this.config.getContext());
-    const tagName = name || this.getContext('tagName');
+    const tagName = name || this.config.getContext('tagName');
     return this.exec(['git', 'tag', '--annotate', '--message', message, ...fixArgs(args), tagName])
       .then(() => this.setContext({ isTagged: true }))
       .catch(err => {
-        const { latestTagName, tagName } = this.getContext();
-        if (/tag '.+' already exists/.test(err) && latestTagName === tagName) {
+        const { latestTag, tagName } = this.config.getContext();
+        if (/tag '.+' already exists/.test(err) && latestTag === tagName) {
           this.log.warn(`Tag "${tagName}" already exists`);
         } else {
           throw err;

package/lib/plugin/git/prompts.js

@@ -8,7 +8,7 @@ export default {
   },
   tag: {
     type: 'confirm',
-    message: context => `Tag (${format(context.git.tagName, context)})?`,
+    message: context => `Tag (${format(context.tagName, context)})?`,
     default: true
   },
   push: {

package/lib/plugin/github/GitHub.js

@@ -1,10 +1,12 @@
 import fs from 'fs';
 import path from 'path';
+import open from 'open';
 import { Octokit } from '@octokit/rest';
-import globby from 'globby';
+import { globby } from 'globby';
 import mime from 'mime-types';
 import _ from 'lodash';
 import retry from 'async-retry';
+import newGithubReleaseUrl from 'new-github-release-url';
 import { format, parseVersion, readJSON, e } from '../../util.js';
 import Release from '../GitRelease.js';
 import prompts from './prompts.js';
@@ -21,7 +23,7 @@ const parseErrormsg = err => {
   let msg = err;
   if (err instanceof Error) {
     const { status, message } = err;
-    const { headers } = err.response;
+    const headers = err.response ? err.response.headers : {};
     msg = `${_.get(headers, 'status', status)} (${message})`;
   }
   return msg;
@@ -36,14 +38,22 @@ class GitHub extends Release {
   async init() {
     await super.init();
 
-    const { skipChecks, tokenRef } = this.options;
-    const { isUpdate } = this.config;
+    const { skipChecks, tokenRef, web, update, assets } = this.options;
 
-    if (!skipChecks) {
-      if (!this.token) {
-        throw e(`Environment variable "${tokenRef}" is required for GitHub releases.`, docs);
+    if (!this.token || web) {
+      if (!web) {
+        this.log.warn(`Environment variable "${tokenRef}" is required for automated GitHub Releases.`);
+        this.log.warn('Falling back to web-based GitHub Release.');
       }
+      this.setContext({ isWeb: true });
+      return;
+    }
 
+    if (web && assets) {
+      this.log.warn('Assets are not included in web-based releases.');
+    }
+
+    if (!skipChecks) {
       // If we're running on GitHub Actions, we can skip the authentication and
       // collaborator checks. Ref: https://bit.ly/2vsyRzu
       if (process.env.GITHUB_ACTIONS) {
@@ -61,11 +71,11 @@ class GitHub extends Release {
       }
     }
 
-    if (isUpdate) {
-      const { latestTagName } = this.getContext();
+    if (update) {
+      const { latestTag } = this.config.getContext();
       try {
         const { id, upload_url, tag_name } = await this.getLatestRelease();
-        if (latestTagName === tag_name) {
+        if (latestTag === tag_name) {
           this.setContext({ isUpdate: true, isReleased: true, releaseId: id, upload_url });
         } else {
           this.setContext({ isUpdate: false });
@@ -74,7 +84,7 @@ class GitHub extends Release {
         this.setContext({ isUpdate: false });
       }
       if (!this.getContext('isUpdate')) {
-        this.log.warn(`GitHub release for tag ${latestTagName} was not found. Creating new release.`);
+        this.log.warn(`GitHub release for tag ${latestTag} was not found. Creating new release.`);
       }
     }
   }
@@ -109,13 +119,16 @@ class GitHub extends Release {
 
   async release() {
     const { assets } = this.options;
-    const { isUpdate } = this.getContext();
+    const { isWeb, isUpdate } = this.getContext();
     const { isCI } = this.config;
 
     const type = isUpdate ? 'update' : 'create';
     const publishMethod = `${type}Release`;
 
-    if (isCI) {
+    if (isWeb) {
+      const task = () => this.createWebRelease();
+      return this.step({ task, label: 'Generating link to GitHub Release web interface', prompt: 'release' });
+    } else if (isCI) {
       await this.step({ task: () => this[publishMethod](), label: `GitHub ${type} release` });
       return this.step({ enabled: assets, task: () => this.uploadAssets(), label: 'GitHub upload assets' });
     } else {
@@ -179,11 +192,12 @@ class GitHub extends Release {
 
   getOctokitReleaseOptions(options = {}) {
     const { owner, project: repo } = this.getContext('repo');
-    const { releaseName, draft = false, preRelease = false } = this.options;
-    const { version, tagName, releaseNotes } = this.getContext();
+    const { releaseName, draft = false, preRelease = false, autoGenerate = false } = this.options;
+    const { tagName } = this.config.getContext();
+    const { version, releaseNotes } = this.getContext();
     const { isPreRelease } = parseVersion(version);
     const name = format(releaseName, this.config.getContext());
-    const body = releaseNotes;
+    const body = autoGenerate ? '' : releaseNotes || '';
 
     return Object.assign(options, {
       owner,
@@ -192,7 +206,8 @@ class GitHub extends Release {
       name,
       body,
       draft,
-      prerelease: isPreRelease || preRelease
+      prerelease: isPreRelease || preRelease,
+      generate_release_notes: autoGenerate
     });
   }
 
@@ -285,6 +300,34 @@ class GitHub extends Release {
     return `https://${host}/${repository}/releases/tag/${tagName}`;
   }
 
+  generateWebUrl() {
+    const host = this.options.host || this.getContext('repo.host');
+    const isGitHub = host === 'github.com';
+
+    const options = this.getOctokitReleaseOptions();
+    const url = newGithubReleaseUrl({
+      user: options.owner,
+      repo: options.repo,
+      tag: options.tag_name,
+      isPrerelease: options.prerelease,
+      title: options.name,
+      body: options.body
+    });
+    return isGitHub ? url : url.replace('github.com', host);
+  }
+
+  async createWebRelease() {
+    const { isCI } = this.config;
+    const { tagName } = this.config.getContext();
+    const url = this.generateWebUrl();
+    if (isCI) {
+      this.setContext({ isReleased: true, releaseUrl: url });
+    } else {
+      await open(url);
+      this.setContext({ isReleased: true, releaseUrl: this.getReleaseUrlFallback(tagName) });
+    }
+  }
+
   updateRelease() {
     const { isDryRun } = this.config;
     const release_id = this.getContext('releaseId');

package/lib/plugin/github/prompts.js

@@ -1,10 +1,10 @@
 import { format } from '../../util.js';
 
 const message = context => {
-  const { isPreRelease, isUpdate, github } = context;
-  const { releaseName } = github;
+  const { isPreRelease, github } = context;
+  const { releaseName, update } = github;
   const name = format(releaseName, context);
-  return `${isUpdate ? 'Update' : 'Create a'} ${isPreRelease ? 'pre-' : ''}release on GitHub (${name})?`;
+  return `${update ? 'Update' : 'Create a'} ${isPreRelease ? 'pre-' : ''}release on GitHub (${name})?`;
 };
 
 export default {

package/lib/plugin/gitlab/GitLab.js

@@ -1,7 +1,7 @@
 import fs from 'fs';
 import path from 'path';
 import got from 'got';
-import globby from 'globby';
+import { globby } from 'globby';
 import FormData from 'form-data';
 import _ from 'lodash';
 import Release from '../GitRelease.js';
@@ -132,7 +132,8 @@ class GitLab extends Release {
 
   async createRelease() {
     const { releaseName } = this.options;
-    const { id, tagName, releaseNotes, repo, origin } = this.getContext();
+    const { tagName } = this.config.getContext();
+    const { id, releaseNotes, repo, origin } = this.getContext();
     const { isDryRun } = this.config;
     const name = format(releaseName, this.config.getContext());
     const description = releaseNotes || '-';

package/lib/plugin/npm/npm.js

@@ -80,7 +80,7 @@ class npm extends Plugin {
     const tag = this.options.tag || (await this.resolveTag(version));
     this.setContext({ version, tag });
 
-    if (this.config.isUpdate) return false;
+    if (!this.config.isIncrement) return false;
 
     const task = () => this.exec(`npm version ${version} --no-git-tag-version`);
     return this.spinner.show({ task, label: 'npm version' });