semantic-release-vsce 5.2.3 → 5.3.0

package/.eslintrc

@@ -1,26 +1,14 @@
 {
-    "env": {
-        "es6": true,
-        "node": true
-    },
-    "extends": "standard",
-    "rules": {
-        "no-console": "off",
-        "indent": [
-            "error",
-            2
-        ],
-        "linebreak-style": [
-            "error",
-            "unix"
-        ],
-        "quotes": [
-            "error",
-            "single"
-        ],
-        "semi": [
-            "error",
-            "always"
-        ]
-    }
+  "env": {
+    "es6": true,
+    "node": true
+  },
+  "extends": ["standard", "prettier"],
+  "rules": {
+    "no-console": "off",
+    "indent": ["error", 2],
+    "linebreak-style": ["error", "unix"],
+    "quotes": ["error", "single"],
+    "semi": ["error", "always"]
+  }
 }

package/.github/workflows/ci.yaml

@@ -19,6 +19,7 @@ jobs:
         node-version:
           - 14
           - 16
+          - 18
 
     steps:
       - uses: actions/checkout@v3

package/.github/workflows/validate-pr-title.yaml

@@ -0,0 +1,16 @@
+name: validate-pr-title
+
+on:
+  pull_request_target:
+    types:
+      - opened
+      - edited
+      - synchronize
+
+jobs:
+  validate-pr-title:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: amannn/action-semantic-pull-request@v5.0.2
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

package/.husky/pre-commit

@@ -1,4 +1,5 @@
 #!/bin/sh
 . "$(dirname "$0")/_/husky.sh"
 
+npx lint-staged
 npm test

package/.prettierignore

@@ -0,0 +1 @@
+.nyc_output

package/.prettierrc

@@ -0,0 +1,3 @@
+{
+  "singleQuote": true
+}

package/README.md

@@ -9,11 +9,11 @@
 [![peerDependencies](https://david-dm.org/felipecrs/semantic-release-vsce/peer-status.svg)](https://david-dm.org/felipecrs/semantic-release-vsce?type=peer)
 [![semantic-release](https://img.shields.io/badge/%20%20%F0%9F%93%A6%F0%9F%9A%80-semantic--release-e10079.svg)](https://github.com/semantic-release/semantic-release)
 
-| Step      | Description                                                                                                                                                                                 |
-| --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `verify`  | Verify the presence and the validity of the authentication (set via [environment variables](#environment-variables)) and the `package.json`                                                 |
-| `prepare` | Generate the `.vsix` file using vsce, this can be be controlled by providing `packageVsix` in config. <br/> _Note: If the `OVSX_PAT` environment variable is set, this step will still run_ |
-| `publish` | Publish the extension                                                                                                                                                                       |
+| Step      | Description                                                                                                                                                                                                          |
+| --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `verify`  | Verify the presence and the validity of the authentication (set via [environment variables](#environment-variables)) and the `package.json`                                                                          |
+| `prepare` | Generate the `.vsix` file using vsce, this can be be controlled by providing `packageVsix` in config. <br/> _Note: If the `OVSX_PAT` environment variable is set, this step will run even if not explicitly enabled_ |
+| `publish` | Publish the extension                                                                                                                                                                                                |
 
 ## Install
 
@@ -47,8 +47,7 @@ The plugin can be configured in the [**semantic-release** configuration file](ht
       {
         "assets": [
           {
-            "path": "*.vsix",
-            "label": "Extension File"
+            "path": "*.vsix"
           }
         ]
       }
@@ -59,17 +58,43 @@ The plugin can be configured in the [**semantic-release** configuration file](ht
 
 ## Configuration
 
-| Option        | Type                  | Description                                                                                                                        |
-| ------------- | --------------------- | ---------------------------------------------------------------------------------------------------------------------------------- |
-| `packageVsix` | `boolean` or `string` | If set to `true`, the plugin will generate a `.vsix` file. If is a string, it will be used as value for `--out` of `vsce package`. |
-| `publish`     | `boolean`             | The plugin will publish the package unless this option is set to `false`, in which case it will only package the extension `vsix`.        |
+### `packageVsix`
 
-### Environment Variables
+Whether to package or not the extension `.vsix`, or where to place it. This controls if `vsce package` gets called or not, and what value will be used for `vsce package --out`.
 
-| Variable   | Description                                                                                                                  |
-| ---------- | ---------------------------------------------------------------------------------------------------------------------------- |
-| `VSCE_PAT` | _**Required**_ unless `publish` is set to `false`. The personal access token to publish the extension of VS Code Marketplace |
-| `OVSX_PAT` | _Optional_. The personal access token to push to OpenVSX                                                                     |
+| Value              | Description                                                                                                  |
+| ------------------ | ------------------------------------------------------------------------------------------------------------ |
+| `"auto"` (default) | behave as `true` in case [`publish`](#publish) is disabled or the `OVSX_PAT` environment variable is present |
+| `true`             | package the extension `.vsix`, and place it at the current working directory                                 |
+| `false`            | disables packaging the extension `.vsix` entirely                                                            |
+| a `string`         | package the extension `.vsix` and place it at the specified path                                             |
+
+### `publish`
+
+Whether to publish or not the extension to Visual Studio Marketplace or OpenVSX (if the `OVSX_PAT` environment variable is present). This controls if `vsce publish` or `ovsx publish` (if the `OVSX_PAT` environment variable is present) gets called or not.
+
+| Value            | Description                                                    |
+| ---------------- | -------------------------------------------------------------- |
+| `true` (default) | publishes the extension to Visual Studio Marketplace           |
+| `false`          | disables publishing the extension to Visual Studio Marketplace |
+
+### `publishPackagePath`
+
+Which `.vsix` file (or files) to publish. This controls what value will be used for `vsce publish --packagePath`.
+
+| Value              | Description                                                                                                       |
+| ------------------ | ----------------------------------------------------------------------------------------------------------------- |
+| `"auto"` (default) | uses the `.vsix` packaged during the `prepare` step (if packaged), or behave as `false` otherwise                 |
+| `false`            | do not use a `.vsix` file to publish, which causes `vsce` to package the extension as part of the publish process |
+| a `string`         | publish the specified `.vsix` file(s). This can be a glob pattern, or a comma-separated list of files             |
+
+### Environment variables
+
+| Variable      | Description                                                                                                                                                                                            |
+| ------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `VSCE_PAT`    | **Required** (unless `publish` is set to `false`). The personal access token to publish the extension to Visual Studio Marketplace                                                                     |
+| `VSCE_TARGET` | _Optional_. The target to use when packaging or publishing the extension (used as `vsce package --target ${VSCE_TARGET}`). See [the platform-specific example](#platform-specific-on-github-actions) ) |
+| `OVSX_PAT`    | _Optional_. The personal access token to push to OpenVSX                                                                                                                                               |
 
 ### Publishing to OpenVSX
 
@@ -79,9 +104,11 @@ Publishing extensions to OpenVSX using this plugin is easy:
 
 2. Configure the `OVSX_PAT` environment variable in your CI with the token that you created.
 
-3. The plugin will automatically detect the environment variable and it will publish to OpenVSX, no additional configuration is needed. Enjoy!
+3. Enjoy! The plugin will automatically detect the environment variable and it will publish to OpenVSX, no additional configuration is needed.
+
+## Examples
 
-### Github Actions Example
+### Github Actions
 
 ```yaml
 name: release
@@ -98,11 +125,164 @@ jobs:
       - uses: actions/setup-node@v3
         with:
           node-version: 16
-      - name: Install Node Dependencies
-        run: npm ci
-      - name: Release
-        run: npx semantic-release
+      - run: npm ci
+      - run: npx semantic-release
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          VSCE_PAT: ${{ secrets.VSCE_PAT }}
+          # In case you want to publish to OpenVSX
+          OVSX_PAT: ${{ secrets.OVSX_PAT }}
+```
+
+### Platform-specific on GitHub Actions
+
+1. Install [`semantic-release-stop-before-publish`](https://github.com/felipecrs/semantic-release-stop-before-publish)
+
+   ```console
+   npm install --save-dev semantic-release-stop-before-publish
+   ```
+
+   We will use it to make `semantic-release` stop before publishing anything, so that we can use `semantic-release` to build each `.vsix` in a matrix.
+
+2. Separate your `semantic-release` configuration into two, one for packaging and another for publishing.
+
+   The one for packaging has `semantic-release-stop-before-publish` so that `semantic-release` does not publish anything (which includes the git tag).
+
+   ```js
+   // package.release.config.js
+   module.exports = {
+     plugins: [
+       '@semantic-release/commit-analyzer',
+       '@semantic-release/release-notes-generator',
+       [
+         'semantic-release-vsce',
+         {
+           packageVsix: true,
+           publish: false, // no-op since we use semantic-release-stop-before-publish
+         },
+       ],
+       'semantic-release-stop-before-publish',
+     ],
+   };
+   ```
+
+   The one for publishing does not package the `.vsix`, but publishes all the `*.vsix` files.
+
+   ```js
+   // publish.release.config.js
+   module.exports = {
+     plugins: [
+       '@semantic-release/commit-analyzer',
+       '@semantic-release/release-notes-generator',
+       [
+         'semantic-release-vsce',
+         {
+           packageVsix: false,
+           publishPackagePath: '*.vsix',
+         },
+       ],
+       [
+         '@semantic-release/github',
+         {
+           assets: '*.vsix',
+         },
+       ],
+     ],
+   };
+   ```
+
+   > **Note:** do not forget to remove your existing `semantic-release` configuration.
+
+3. Create a workflow file like below:
+
+```yaml
+# .github/workflows/ci.yaml
+name: ci
+
+on:
+  push:
+    branches: [master]
+
+jobs:
+  build:
+    strategy:
+      matrix:
+        include:
+          - os: windows-latest
+            platform: win32
+            arch: x64
+            npm_config_arch: x64
+          - os: windows-latest
+            platform: win32
+            arch: ia32
+            npm_config_arch: ia32
+          - os: windows-latest
+            platform: win32
+            arch: arm64
+            npm_config_arch: arm
+          - os: ubuntu-latest
+            platform: linux
+            arch: x64
+            npm_config_arch: x64
+          - os: ubuntu-latest
+            platform: linux
+            arch: arm64
+            npm_config_arch: arm64
+          - os: ubuntu-latest
+            platform: linux
+            arch: armhf
+            npm_config_arch: arm
+          - os: ubuntu-latest
+            platform: alpine
+            arch: x64
+            npm_config_arch: x64
+          - os: macos-latest
+            platform: darwin
+            arch: x64
+            npm_config_arch: x64
+          - os: macos-latest
+            platform: darwin
+            arch: arm64
+            npm_config_arch: arm64
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-node@v3
+        with:
+          node-version: 16
+      - run: npm ci
+        env:
+          npm_config_arch: ${{ matrix.npm_config_arch }}
+      - shell: pwsh
+        run: echo "target=${{ matrix.platform }}-${{ matrix.arch }}" >> $env:GITHUB_ENV
+      - run: npx semantic-release --extends package.release.config.js
+        env:
+          VSCE_TARGET: ${{ env.target }}
+          # All tokens are required since semantic-release needs to validate them
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          VSCE_PAT: ${{ secrets.VSCE_PAT }}
+          # In case you want to publish to OpenVSX
+          OVSX_PAT: ${{ secrets.OVSX_PAT }}
+
+      - uses: actions/upload-artifact@v3
+        with:
+          name: ${{ env.target }}
+          path: '*.vsix'
+
+  release:
+    runs-on: ubuntu-latest
+    needs: build
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-node@v3
+        with:
+          node-version: 16
+      - run: npm ci
+      - uses: actions/download-artifact@v3
+      - run: npx semantic-release --extends publish.release.config.js
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
           VSCE_PAT: ${{ secrets.VSCE_PAT }}
+          # In case you want to publish to OpenVSX
+          OVSX_PAT: ${{ secrets.OVSX_PAT }}
 ```

package/index.js

@@ -8,21 +8,32 @@ let verified = false;
 let prepared = false;
 let packagePath;
 
-async function verifyConditions (pluginConfig, { logger, cwd }) {
+async function verifyConditions(pluginConfig, { logger, cwd }) {
   await verifyVsce(pluginConfig, { logger, cwd });
   verified = true;
 }
 
-async function prepare (pluginConfig, { nextRelease: { version }, logger, cwd }) {
+async function prepare(
+  pluginConfig,
+  { nextRelease: { version }, logger, cwd }
+) {
   if (!verified) {
     await verifyVsce(pluginConfig, { logger, cwd });
     verified = true;
   }
-  packagePath = await vscePrepare(version, pluginConfig.packageVsix, logger, cwd);
+  packagePath = await vscePrepare(
+    version,
+    pluginConfig.packageVsix,
+    logger,
+    cwd
+  );
   prepared = true;
 }
 
-async function publish (pluginConfig, { nextRelease: { version }, logger, cwd }) {
+async function publish(
+  pluginConfig,
+  { nextRelease: { version }, logger, cwd }
+) {
   if (!verified) {
     await verifyVsce(pluginConfig, { logger, cwd });
     verified = true;
@@ -30,7 +41,12 @@ async function publish (pluginConfig, { nextRelease: { version }, logger, cwd })
 
   if (!prepared) {
     // BC: prior to semantic-release v15 prepare was part of publish
-    packagePath = await vscePrepare(version, pluginConfig.packageVsix, logger, cwd);
+    packagePath = await vscePrepare(
+      version,
+      pluginConfig.packageVsix,
+      logger,
+      cwd
+    );
   }
 
   // If publishing is disabled, return early.
@@ -38,11 +54,17 @@ async function publish (pluginConfig, { nextRelease: { version }, logger, cwd })
     return;
   }
 
-  return vscePublish(version, packagePath, logger);
+  if (pluginConfig?.publishPackagePath) {
+    // Expand glob
+    const glob = require('glob');
+    packagePath = glob.sync(pluginConfig.publishPackagePath, { cwd });
+  }
+
+  return vscePublish(version, packagePath, logger, cwd);
 }
 
 module.exports = {
   verifyConditions,
   prepare,
-  publish
+  publish,
 };

package/lib/prepare.js

@@ -2,13 +2,20 @@
 
 const execa = require('execa');
 const { readJson } = require('fs-extra');
-const { isOvsxEnabled } = require('./verify-ovsx-auth');
+const { isOvsxEnabled, isTargetEnabled } = require('./utils');
 
 module.exports = async (version, packageVsix, logger, cwd) => {
+  if (packageVsix === false) {
+    return;
+  }
+
   const ovsxEnabled = isOvsxEnabled();
+
   if (packageVsix || ovsxEnabled) {
     if (!packageVsix && ovsxEnabled) {
-      logger.log('Packaging to VSIX even though `packageVsix` is not set as publish to OpenVSX is enabled.');
+      logger.log(
+        'Packaging to VSIX even though `packageVsix` is not set as publish to OpenVSX is enabled.'
+      );
     }
 
     let packagePath;
@@ -17,12 +24,25 @@ module.exports = async (version, packageVsix, logger, cwd) => {
       packagePath = packageVsix;
     } else {
       const { name } = await readJson('./package.json');
-      packagePath = `${name}-${version}.vsix`;
+      if (isTargetEnabled()) {
+        packagePath = `${name}-${process.env.VSCE_TARGET}-${version}.vsix`;
+      } else {
+        packagePath = `${name}-${version}.vsix`;
+      }
     }
 
     logger.log(`Packaging version ${version} to ${packagePath}`);
 
-    const options = ['package', version, '--no-git-tag-version', '--out', packagePath];
+    const options = [
+      'package',
+      version,
+      '--no-git-tag-version',
+      '--out',
+      packagePath,
+    ];
+    if (process.env.VSCE_TARGET) {
+      options.push('--target', process.env.VSCE_TARGET);
+    }
 
     await execa('vsce', options, { stdio: 'inherit', preferLocal: true, cwd });
 

package/lib/publish.js

@@ -2,20 +2,33 @@
 
 const execa = require('execa');
 const { readJson } = require('fs-extra');
-const { isOvsxEnabled } = require('./verify-ovsx-auth');
+const { isOvsxEnabled, isTargetEnabled } = require('./utils');
 
 module.exports = async (version, packagePath, logger, cwd) => {
   const { publisher, name } = await readJson('./package.json');
 
   const options = ['publish'];
 
+  let message = `Publishing version ${version}`;
   if (packagePath) {
-    logger.log(`Publishing version ${version} from ${packagePath} to Visual Studio Marketplace`);
-    options.push(...['--packagePath', packagePath]);
+    // Ensure packagePath is a list
+    if (typeof packagePath === 'string') {
+      packagePath = [packagePath];
+    }
+
+    options.push('--packagePath', ...packagePath);
+    message += ` from ${packagePath.join(', ')}`;
   } else {
-    logger.log(`Publishing version ${version} to Visual Studio Marketplace`);
-    options.push(...[version, '--no-git-tag-version']);
+    options.push(version, '--no-git-tag-version');
+
+    if (isTargetEnabled()) {
+      // @ts-ignore
+      options.push('--target', process.env.VSCE_TARGET);
+      message += ` for target ${process.env.VSCE_TARGET}`;
+    }
   }
+  message += ' to Visual Studio Marketplace';
+  logger.log(message);
 
   await execa('vsce', options, { stdio: 'inherit', preferLocal: true, cwd });
 
@@ -24,13 +37,14 @@ module.exports = async (version, packagePath, logger, cwd) => {
 
   const vsceRelease = {
     name: 'Visual Studio Marketplace',
-    url: vsceUrl
+    url: vsceUrl,
   };
 
   if (isOvsxEnabled()) {
     logger.log('Now publishing to OpenVSX');
 
-    await execa('ovsx', ['publish', packagePath], { stdio: 'inherit', preferLocal: true, cwd });
+    // When publishing to OpenVSX, packagePath will be always set
+    await execa('ovsx', options, { stdio: 'inherit', preferLocal: true, cwd });
     const ovsxUrl = `https://open-vsx.org/extension/${publisher}/${name}/${version}`;
 
     logger.log(`The new ovsx version is available at ${ovsxUrl}`);

package/lib/utils.js

@@ -0,0 +1,12 @@
+const isOvsxEnabled = () => {
+  return 'OVSX_PAT' in process.env;
+};
+
+const isTargetEnabled = () => {
+  return 'VSCE_TARGET' in process.env;
+};
+
+module.exports = {
+  isTargetEnabled,
+  isOvsxEnabled,
+};

package/lib/verify-auth.js

@@ -7,12 +7,18 @@ module.exports = async (logger, cwd) => {
   logger.log('Verifying authentication for vsce');
 
   if (!process.env.VSCE_PAT) {
-    throw new SemanticReleaseError('No vsce personal access token specified (set the `VSCE_PAT` environment variable).', 'ENOVSCEPAT');
+    throw new SemanticReleaseError(
+      'No vsce personal access token specified (set the `VSCE_PAT` environment variable).',
+      'ENOVSCEPAT'
+    );
   }
 
   try {
     await execa('vsce', ['verify-pat'], { preferLocal: true, cwd });
   } catch (e) {
-    throw new SemanticReleaseError(`Invalid vsce token. Additional information:\n\n${e}`, 'EINVALIDVSCETOKEN');
+    throw new SemanticReleaseError(
+      `Invalid vsce token. Additional information:\n\n${e}`,
+      'EINVALIDVSCETOKEN'
+    );
   }
 };

package/lib/verify-ovsx-auth.js

@@ -1,21 +1,23 @@
 // @ts-check
 
 const SemanticReleaseError = require('@semantic-release/error');
-
-const isOvsxEnabled = () => {
-  return 'OVSX_PAT' in process.env;
-};
+const { isOvsxEnabled } = require('./utils');
 
 module.exports = async (logger) => {
   logger.log('Verifying authentication for ovsx');
 
   if (!isOvsxEnabled()) {
-    logger.log('Skipping verification of ovsx personal token because the `OVSX_PAT` environment variable is not set.\n\nDid you know you can easily start publishing to OpenVSX with `semantic-release-vsce`?\nLearn more at https://github.com/felipecrs/semantic-release-vsce#publishing-to-openvsx');
+    logger.log(
+      'Skipping verification of ovsx personal token because the `OVSX_PAT` environment variable is not set.\n\nDid you know you can easily start publishing to OpenVSX with `semantic-release-vsce`?\nLearn more at https://github.com/felipecrs/semantic-release-vsce#publishing-to-openvsx'
+    );
     return;
   }
 
   if (!process.env.OVSX_PAT) {
-    throw new SemanticReleaseError('Empty ovsx personal access token specified.', 'EINVALIDOVSXPAT');
+    throw new SemanticReleaseError(
+      'Empty ovsx personal access token specified.',
+      'EINVALIDOVSXPAT'
+    );
   }
 
   // TODO: waiting for https://github.com/eclipse/openvsx/issues/313
@@ -25,5 +27,3 @@ module.exports = async (logger) => {
   //   throw new SemanticReleaseError(`Invalid ovsx personal access token. Additional information:\n\n${e}`, 'EINVALIDOVSXPAT');
   // }
 };
-
-module.exports.isOvsxEnabled = isOvsxEnabled;

package/lib/verify-pkg.js

@@ -17,15 +17,24 @@ module.exports = async () => {
   try {
     packageJson = await readJson('./package.json');
   } catch (error) {
-    throw new SemanticReleaseError('The `package.json` seems to be invalid.', 'EINVALIDPKG');
+    throw new SemanticReleaseError(
+      'The `package.json` seems to be invalid.',
+      'EINVALIDPKG'
+    );
   }
 
   const { name, publisher } = packageJson;
 
   if (!name) {
-    throw new SemanticReleaseError('No `name` found in `package.json`.', 'ENOPKGNAME');
+    throw new SemanticReleaseError(
+      'No `name` found in `package.json`.',
+      'ENOPKGNAME'
+    );
   }
   if (!publisher) {
-    throw new SemanticReleaseError('No `publisher` found in `package.json`.', 'ENOPUBLISHER');
+    throw new SemanticReleaseError(
+      'No `publisher` found in `package.json`.',
+      'ENOPUBLISHER'
+    );
   }
 };

package/lib/verify-target.js

@@ -0,0 +1,29 @@
+// @ts-check
+
+const SemanticReleaseError = require('@semantic-release/error');
+const { isTargetEnabled } = require('./utils');
+
+module.exports = async () => {
+  if (!isTargetEnabled()) {
+    return;
+  }
+
+  if (!process.env.VSCE_TARGET) {
+    throw new SemanticReleaseError(
+      'Empty vsce target specified.',
+      'EINVALIDVSCETARGET'
+    );
+  }
+
+  const targets = require('vsce/out/package').Targets;
+
+  // Throw if the target is not supported
+  if (!targets.has(process.env.VSCE_TARGET)) {
+    throw new SemanticReleaseError(
+      `Unsupported vsce target: ${
+        process.env.VSCE_TARGET
+      }. Available targets: ${Object.values(targets).join(', ')}`,
+      'EUNSUPPORTEDVSCETARGET'
+    );
+  }
+};

package/lib/verify.js

@@ -3,9 +3,11 @@
 const verifyPkg = require('./verify-pkg');
 const verifyAuth = require('./verify-auth');
 const verifyOvsxAuth = require('./verify-ovsx-auth');
+const verifyTarget = require('./verify-target');
 
 module.exports = async (pluginConfig, { logger, cwd }) => {
   await verifyPkg();
+  await verifyTarget();
 
   if (pluginConfig?.publish !== false) {
     await verifyAuth(logger, cwd);