semantic-release-vsce 5.2.4 → 5.4.0

package/lib/verify.js

@@ -3,12 +3,14 @@
 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);
-    await verifyOvsxAuth(logger);
+    await verifyOvsxAuth(logger, cwd);
   }
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "semantic-release-vsce",
-  "version": "5.2.4",
+  "version": "5.4.0",
   "description": "semantic-release plugin to package and publish VS Code extensions",
   "license": "MIT",
   "engines": {
@@ -10,6 +10,9 @@
   "bugs": "https://github.com/felipecrs/semantic-release-vsce/issues",
   "homepage": "https://github.com/felipecrs/semantic-release-vsce#readme",
   "author": "Morten Henriksen <mh@gi2.dk>",
+  "contributors": [
+    "Felipe Santos <felipecassiors@gmail.com>"
+  ],
   "keywords": [
     "semantic-release",
     "semantic-release-plugin",
@@ -18,7 +21,7 @@
   ],
   "main": "index.js",
   "scripts": {
-    "lint": "eslint .",
+    "lint": "prettier --check . && eslint .",
     "release": "semantic-release",
     "test": "nyc ava",
     "posttest": "npm run lint",
@@ -29,11 +32,6 @@
       "test/**/*.test.js"
     ]
   },
-  "commitlint": {
-    "extends": [
-      "@commitlint/config-conventional"
-    ]
-  },
   "nyc": {
     "all": true,
     "exclude": [
@@ -45,33 +43,38 @@
     ]
   },
   "volta": {
-    "node": "16.15.1",
-    "npm": "8.12.1"
+    "node": "18.12.1",
+    "npm": "9.1.1"
   },
   "dependencies": {
     "@semantic-release/error": "^3.0.0",
+    "@vscode/vsce": "^2.15.0",
     "execa": "^5.0.0",
-    "fs-extra": "^10.0.0",
-    "ovsx": "^0.5.0",
-    "vsce": "^2.6.3"
+    "fs-extra": "^11.1.0",
+    "glob": "^8.0.3",
+    "ovsx": "^0.6.0"
   },
   "peerDependencies": {
     "semantic-release": ">=18"
   },
   "devDependencies": {
-    "@commitlint/cli": "^17.0.0",
-    "@commitlint/config-conventional": "^17.0.0",
     "ava": "^5.0.1",
     "conventional-changelog-conventionalcommits": "^5.0.0",
     "eslint": "^8.7.0",
+    "eslint-config-prettier": "^8.5.0",
     "eslint-config-standard": "^17.0.0",
     "eslint-plugin-import": "^2.20.1",
     "eslint-plugin-n": "^15.2.1",
     "eslint-plugin-promise": "^6.0.0",
-    "husky": "^8.0.1",
+    "husky": "^8.0.2",
+    "lint-staged": "^13.0.3",
     "nyc": "^15.1.0",
+    "prettier": "2.8.0",
     "proxyquire": "^2.1.3",
     "semantic-release": "^19.0.2",
-    "sinon": "^14.0.0"
+    "sinon": "^15.0.0"
+  },
+  "lint-staged": {
+    "**/*": "prettier --write --ignore-unknown"
   }
 }

package/release.config.js

@@ -6,19 +6,19 @@ module.exports = {
         releaseRules: [
           {
             type: 'perf',
-            release: 'patch'
+            release: 'patch',
           },
           {
             type: 'refactor',
-            release: 'patch'
+            release: 'patch',
           },
           {
             type: 'build',
             scope: 'deps',
-            release: 'patch'
-          }
-        ]
-      }
+            release: 'patch',
+          },
+        ],
+      },
     ],
     [
       '@semantic-release/release-notes-generator',
@@ -27,40 +27,40 @@ module.exports = {
           types: [
             {
               type: 'feat',
-              section: 'Features'
+              section: 'Features',
             },
             {
               type: 'fix',
-              section: 'Bug Fixes'
+              section: 'Bug Fixes',
             },
             {
               type: 'perf',
-              section: 'Performance Improvements'
+              section: 'Performance Improvements',
             },
             {
               type: 'revert',
-              section: 'Reverts'
+              section: 'Reverts',
             },
             {
               type: 'refactor',
-              section: 'Code Refactoring'
+              section: 'Code Refactoring',
             },
             {
               type: 'build',
               scope: 'deps',
-              section: 'Dependencies'
-            }
-          ]
-        }
-      }
+              section: 'Dependencies',
+            },
+          ],
+        },
+      },
     ],
     '@semantic-release/npm',
     [
       '@semantic-release/github',
       {
-        addReleases: 'bottom'
-      }
-    ]
+        addReleases: 'bottom',
+      },
+    ],
   ],
-  preset: 'conventionalcommits'
+  preset: 'conventionalcommits',
 };

package/test/index.test.js

@@ -4,71 +4,81 @@ const proxyquire = require('proxyquire');
 
 const semanticReleasePayload = {
   nextRelease: {
-    version: '1.0.0'
+    version: '1.0.0',
   },
   logger: {
-    log: sinon.fake()
+    log: sinon.fake(),
   },
-  cwd: process.cwd()
+  cwd: process.cwd(),
 };
 
 const pluginConfig = {
-  packageVsix: 'test.vsix'
+  packageVsix: 'test.vsix',
 };
 
-test.beforeEach(t => {
+test.beforeEach((t) => {
   t.context.stubs = {
     verifyVsceStub: sinon.stub().resolves(),
     vscePublishStub: sinon.stub().resolves(),
-    vscePrepareStub: sinon.stub().resolves()
+    vscePrepareStub: sinon.stub().resolves(),
   };
 });
 
-test.afterEach(t => {
-  Object.keys(t.context.stubs).forEach(key => {
+test.afterEach((t) => {
+  Object.keys(t.context.stubs).forEach((key) => {
     t.context.stubs[key].resetHistory();
   });
 });
 
-test('verifyConditions', async t => {
+test('verifyConditions', async (t) => {
   const { verifyVsceStub, vscePrepareStub, vscePublishStub } = t.context.stubs;
   const { verifyConditions } = proxyquire('../index.js', {
     './lib/verify': verifyVsceStub,
     './lib/publish': vscePublishStub,
-    './lib/prepare': vscePrepareStub
+    './lib/prepare': vscePrepareStub,
   });
 
   await verifyConditions(pluginConfig, semanticReleasePayload);
 
-  t.true(verifyVsceStub.calledOnceWith(pluginConfig, { logger: semanticReleasePayload.logger, cwd: semanticReleasePayload.cwd }));
+  t.true(
+    verifyVsceStub.calledOnceWith(pluginConfig, {
+      logger: semanticReleasePayload.logger,
+      cwd: semanticReleasePayload.cwd,
+    })
+  );
 });
 
-test('prepare and unverified', async t => {
+test('prepare and unverified', async (t) => {
   const { verifyVsceStub, vscePrepareStub, vscePublishStub } = t.context.stubs;
   const { prepare } = proxyquire('../index.js', {
     './lib/verify': verifyVsceStub,
     './lib/publish': vscePublishStub,
     './lib/prepare': vscePrepareStub,
-    verified: false
+    verified: false,
   });
 
   await prepare(pluginConfig, semanticReleasePayload);
 
-  t.true(verifyVsceStub.calledOnceWith(pluginConfig, { logger: semanticReleasePayload.logger, cwd: semanticReleasePayload.cwd }));
+  t.true(
+    verifyVsceStub.calledOnceWith(pluginConfig, {
+      logger: semanticReleasePayload.logger,
+      cwd: semanticReleasePayload.cwd,
+    })
+  );
   t.deepEqual(vscePrepareStub.getCall(0).args, [
     semanticReleasePayload.nextRelease.version,
     pluginConfig.packageVsix,
     semanticReleasePayload.logger,
-    semanticReleasePayload.cwd
+    semanticReleasePayload.cwd,
   ]);
 });
 
-test('prepare and verified', async t => {
+test('prepare and verified', async (t) => {
   const { verifyVsceStub, vscePrepareStub, vscePublishStub } = t.context.stubs;
   const { prepare, verifyConditions } = proxyquire('../index.js', {
     './lib/verify': verifyVsceStub,
     './lib/publish': vscePublishStub,
-    './lib/prepare': vscePrepareStub
+    './lib/prepare': vscePrepareStub,
   });
 
   await verifyConditions(pluginConfig, semanticReleasePayload);
@@ -79,16 +89,16 @@ test('prepare and verified', async t => {
     semanticReleasePayload.nextRelease.version,
     pluginConfig.packageVsix,
     semanticReleasePayload.logger,
-    semanticReleasePayload.cwd
+    semanticReleasePayload.cwd,
   ]);
 });
 
-test('publish that is unverified and unprepared', async t => {
+test('publish that is unverified and unprepared', async (t) => {
   const { verifyVsceStub, vscePrepareStub, vscePublishStub } = t.context.stubs;
   const { publish } = proxyquire('../index.js', {
     './lib/verify': verifyVsceStub,
     './lib/publish': vscePublishStub,
-    './lib/prepare': vscePrepareStub
+    './lib/prepare': vscePrepareStub,
   });
 
   await publish(pluginConfig, semanticReleasePayload);
@@ -98,16 +108,17 @@ test('publish that is unverified and unprepared', async t => {
   t.deepEqual(vscePublishStub.getCall(0).args, [
     semanticReleasePayload.nextRelease.version,
     undefined,
-    semanticReleasePayload.logger
+    semanticReleasePayload.logger,
+    semanticReleasePayload.cwd,
   ]);
 });
 
-test('publish that is verified but unprepared', async t => {
+test('publish that is verified but unprepared', async (t) => {
   const { verifyVsceStub, vscePrepareStub, vscePublishStub } = t.context.stubs;
   const { publish, verifyConditions } = proxyquire('../index.js', {
     './lib/verify': verifyVsceStub,
     './lib/publish': vscePublishStub,
-    './lib/prepare': vscePrepareStub
+    './lib/prepare': vscePrepareStub,
   });
 
   await verifyConditions(pluginConfig, semanticReleasePayload);
@@ -118,16 +129,17 @@ test('publish that is verified but unprepared', async t => {
   t.deepEqual(vscePublishStub.getCall(0).args, [
     semanticReleasePayload.nextRelease.version,
     undefined,
-    semanticReleasePayload.logger
+    semanticReleasePayload.logger,
+    semanticReleasePayload.cwd,
   ]);
 });
 
-test('publish that is already verified & prepared', async t => {
+test('publish that is already verified & prepared', async (t) => {
   const { verifyVsceStub, vscePrepareStub, vscePublishStub } = t.context.stubs;
   const { prepare, publish, verifyConditions } = proxyquire('../index.js', {
     './lib/verify': verifyVsceStub,
     './lib/publish': vscePublishStub,
-    './lib/prepare': vscePrepareStub
+    './lib/prepare': vscePrepareStub,
   });
 
   await verifyConditions(pluginConfig, semanticReleasePayload);
@@ -139,21 +151,53 @@ test('publish that is already verified & prepared', async t => {
   t.deepEqual(vscePublishStub.getCall(0).args, [
     semanticReleasePayload.nextRelease.version,
     packagePath,
-    semanticReleasePayload.logger
+    semanticReleasePayload.logger,
+    semanticReleasePayload.cwd,
   ]);
 });
 
-test('it does not publish the package if publishing is disabled', async t => {
+test('it does not publish the package if publishing is disabled', async (t) => {
   const { verifyVsceStub, vscePrepareStub, vscePublishStub } = t.context.stubs;
   const { prepare, publish, verifyConditions } = proxyquire('../index.js', {
     './lib/verify': verifyVsceStub,
     './lib/publish': vscePublishStub,
-    './lib/prepare': vscePrepareStub
+    './lib/prepare': vscePrepareStub,
   });
 
-  await verifyConditions({ ...pluginConfig, publish: false }, semanticReleasePayload);
+  await verifyConditions(
+    { ...pluginConfig, publish: false },
+    semanticReleasePayload
+  );
   await prepare({ ...pluginConfig, publish: false }, semanticReleasePayload);
   await publish({ ...pluginConfig, publish: false }, semanticReleasePayload);
 
   t.true(vscePublishStub.notCalled);
 });
+
+test('expand globs if publishPackagePath is set', async (t) => {
+  const { verifyVsceStub, vscePrepareStub, vscePublishStub } = t.context.stubs;
+  const { publish } = proxyquire('../index.js', {
+    './lib/verify': verifyVsceStub,
+    './lib/publish': vscePublishStub,
+    './lib/prepare': vscePrepareStub,
+    glob: {
+      sync: sinon.stub().returns(['package1.vsix', 'package2.vsix']),
+    },
+  });
+
+  const pluginConfig = {
+    publishPackagePath: 'package*.vsix',
+    packageVsix: false,
+  };
+
+  await publish(pluginConfig, semanticReleasePayload);
+
+  t.true(verifyVsceStub.calledOnce);
+  t.true(vscePrepareStub.calledOnce);
+  t.deepEqual(vscePublishStub.getCall(0).args, [
+    semanticReleasePayload.nextRelease.version,
+    ['package1.vsix', 'package2.vsix'],
+    semanticReleasePayload.logger,
+    semanticReleasePayload.cwd,
+  ]);
+});

package/test/prepare.test.js

@@ -1,26 +1,39 @@
+// Run tests serially to avoid env pollution
+const test = require('ava').serial;
 const sinon = require('sinon');
-const test = require('ava');
 const proxyquire = require('proxyquire');
 
 const logger = {
-  log: sinon.fake()
+  log: sinon.fake(),
 };
 const cwd = process.cwd();
 
-test.beforeEach(t => {
+test.beforeEach((t) => {
   t.context.stubs = {
-    execaStub: sinon.stub()
+    execaStub: sinon.stub(),
   };
 });
 
-test.afterEach(t => {
+test.afterEach((t) => {
   t.context.stubs.execaStub.resetHistory();
 });
 
-test('packageVsix is not specified', async t => {
+test('packageVsix is disabled', async (t) => {
   const { execaStub } = t.context.stubs;
   const prepare = proxyquire('../lib/prepare', {
-    execa: execaStub
+    execa: execaStub,
+  });
+
+  const version = '1.0.0';
+  await prepare(version, false, logger);
+
+  t.true(execaStub.notCalled);
+});
+
+test('packageVsix is not specified', async (t) => {
+  const { execaStub } = t.context.stubs;
+  const prepare = proxyquire('../lib/prepare', {
+    execa: execaStub,
   });
 
   const version = '1.0.0';
@@ -29,10 +42,10 @@ test('packageVsix is not specified', async t => {
   t.true(execaStub.notCalled);
 });
 
-test('packageVsix is a string', async t => {
+test('packageVsix is a string', async (t) => {
   const { execaStub } = t.context.stubs;
   const prepare = proxyquire('../lib/prepare', {
-    execa: execaStub
+    execa: execaStub,
   });
 
   const version = '1.0.0';
@@ -41,10 +54,14 @@ test('packageVsix is a string', async t => {
   const result = await prepare(version, packageVsix, logger, cwd);
 
   t.deepEqual(result, packagePath);
-  t.deepEqual(execaStub.getCall(0).args, ['vsce', ['package', version, '--no-git-tag-version', '--out', packagePath], { stdio: 'inherit', preferLocal: true, cwd }]);
+  t.deepEqual(execaStub.getCall(0).args, [
+    'vsce',
+    ['package', version, '--no-git-tag-version', '--out', packagePath],
+    { stdio: 'inherit', preferLocal: true, cwd },
+  ]);
 });
 
-test('packageVsix is true', async t => {
+test('packageVsix is true', async (t) => {
   const { execaStub } = t.context.stubs;
   const name = 'test';
 
@@ -52,9 +69,9 @@ test('packageVsix is true', async t => {
     execa: execaStub,
     'fs-extra': {
       readJson: sinon.stub().returns({
-        name
-      })
-    }
+        name,
+      }),
+    },
   });
 
   const version = '1.0.0';
@@ -64,10 +81,14 @@ test('packageVsix is true', async t => {
   const result = await prepare(version, packageVsix, logger, cwd);
 
   t.deepEqual(result, packagePath);
-  t.deepEqual(execaStub.getCall(0).args, ['vsce', ['package', version, '--no-git-tag-version', '--out', packagePath], { stdio: 'inherit', preferLocal: true, cwd }]);
+  t.deepEqual(execaStub.getCall(0).args, [
+    'vsce',
+    ['package', version, '--no-git-tag-version', '--out', packagePath],
+    { stdio: 'inherit', preferLocal: true, cwd },
+  ]);
 });
 
-test('packageVsix is not set but OVSX_PAT is', async t => {
+test('packageVsix is not set but OVSX_PAT is', async (t) => {
   const { execaStub } = t.context.stubs;
   const name = 'test';
 
@@ -75,13 +96,13 @@ test('packageVsix is not set but OVSX_PAT is', async t => {
     execa: execaStub,
     'fs-extra': {
       readJson: sinon.stub().returns({
-        name
-      })
-    }
+        name,
+      }),
+    },
   });
 
   sinon.stub(process, 'env').value({
-    OVSX_PAT: 'abc123'
+    OVSX_PAT: 'abc123',
   });
 
   const version = '1.0.0';
@@ -91,5 +112,48 @@ test('packageVsix is not set but OVSX_PAT is', async t => {
   const result = await prepare(version, packageVsix, logger, cwd);
 
   t.deepEqual(result, packagePath);
-  t.deepEqual(execaStub.getCall(0).args, ['vsce', ['package', version, '--no-git-tag-version', '--out', packagePath], { stdio: 'inherit', preferLocal: true, cwd }]);
+  t.deepEqual(execaStub.getCall(0).args, [
+    'vsce',
+    ['package', version, '--no-git-tag-version', '--out', packagePath],
+    { stdio: 'inherit', preferLocal: true, cwd },
+  ]);
+});
+
+test('packageVsix when target is set', async (t) => {
+  const { execaStub } = t.context.stubs;
+  const name = 'test';
+
+  const prepare = proxyquire('../lib/prepare', {
+    execa: execaStub,
+    'fs-extra': {
+      readJson: sinon.stub().returns({
+        name,
+      }),
+    },
+  });
+
+  const version = '1.0.0';
+  const target = 'linux-x64';
+  const packagePath = `${name}-${target}-${version}.vsix`;
+
+  sinon.stub(process, 'env').value({
+    VSCE_TARGET: target,
+  });
+
+  const result = await prepare(version, true, logger, cwd);
+
+  t.deepEqual(result, packagePath);
+  t.deepEqual(execaStub.getCall(0).args, [
+    'vsce',
+    [
+      'package',
+      version,
+      '--no-git-tag-version',
+      '--out',
+      packagePath,
+      '--target',
+      target,
+    ],
+    { stdio: 'inherit', preferLocal: true, cwd },
+  ]);
 });