vsce
Version:
VSCode Extension Manager
1,156 lines (1,155 loc) • 56.6 kB
JavaScript
"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
}) : (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
o["default"] = v;
});
var __importStar = (this && this.__importStar) || function (mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
__setModuleDefault(result, mod);
return result;
};
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.ls = exports.listFiles = exports.packageCommand = exports.pack = exports.prepublish = exports.collect = exports.createDefaultProcessors = exports.processFiles = exports.toContentTypes = exports.toVsixManifest = exports.readManifest = exports.validateManifest = exports.ValidationProcessor = exports.NLSProcessor = exports.isWebKind = exports.ChangelogProcessor = exports.ReadmeProcessor = exports.MarkdownProcessor = exports.TagsProcessor = exports.ManifestProcessor = exports.Targets = exports.versionBump = exports.BaseProcessor = exports.read = void 0;
const fs = __importStar(require("fs"));
const path = __importStar(require("path"));
const util_1 = require("util");
const cp = __importStar(require("child_process"));
const yazl = __importStar(require("yazl"));
const nls_1 = require("./nls");
const util = __importStar(require("./util"));
const glob_1 = __importDefault(require("glob"));
const minimatch_1 = __importDefault(require("minimatch"));
const markdown_it_1 = __importDefault(require("markdown-it"));
const cheerio = __importStar(require("cheerio"));
const url = __importStar(require("url"));
const mime_1 = __importDefault(require("mime"));
const semver = __importStar(require("semver"));
const url_join_1 = __importDefault(require("url-join"));
const validation_1 = require("./validation");
const npm_1 = require("./npm");
const GitHost = __importStar(require("hosted-git-info"));
const parse_semver_1 = __importDefault(require("parse-semver"));
const MinimatchOptions = { dot: true };
function isInMemoryFile(file) {
return !!file.contents;
}
function read(file) {
if (isInMemoryFile(file)) {
return Promise.resolve(file.contents).then(b => (typeof b === 'string' ? b : b.toString('utf8')));
}
else {
return fs.promises.readFile(file.localPath, 'utf8');
}
}
exports.read = read;
class BaseProcessor {
constructor(manifest) {
this.manifest = manifest;
this.assets = [];
this.tags = [];
this.vsix = Object.create(null);
}
async onFile(file) {
return file;
}
async onEnd() {
// noop
}
}
exports.BaseProcessor = BaseProcessor;
// https://github.com/npm/cli/blob/latest/lib/utils/hosted-git-info-from-manifest.js
function getGitHost(manifest) {
const url = getRepositoryUrl(manifest);
return url ? GitHost.fromUrl(url, { noGitPlus: true }) : undefined;
}
// https://github.com/npm/cli/blob/latest/lib/repo.js
function getRepositoryUrl(manifest, gitHost) {
if (gitHost) {
return gitHost.https();
}
let url = undefined;
if (manifest.repository) {
if (typeof manifest.repository === 'string') {
url = manifest.repository;
}
else if (typeof manifest.repository === 'object' &&
manifest.repository.url &&
typeof manifest.repository.url === 'string') {
url = manifest.repository.url;
}
}
return url;
}
// https://github.com/npm/cli/blob/latest/lib/bugs.js
function getBugsUrl(manifest, gitHost) {
if (manifest.bugs) {
if (typeof manifest.bugs === 'string') {
return manifest.bugs;
}
if (typeof manifest.bugs === 'object' && manifest.bugs.url) {
return manifest.bugs.url;
}
if (typeof manifest.bugs === 'object' && manifest.bugs.email) {
return `mailto:${manifest.bugs.email}`;
}
}
if (gitHost) {
return gitHost.bugs();
}
return undefined;
}
// https://github.com/npm/cli/blob/latest/lib/docs.js
function getHomepageUrl(manifest, gitHost) {
if (manifest.homepage) {
return manifest.homepage;
}
if (gitHost) {
return gitHost.docs();
}
return undefined;
}
// Contributed by Mozilla developer authors
// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions
function escapeRegExp(value) {
return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); // $& means the whole matched string
}
function toExtensionTags(extensions) {
return extensions
.map(s => s.replace(/\W/g, ''))
.filter(s => !!s)
.map(s => `__ext_${s}`);
}
function toLanguagePackTags(translations, languageId) {
return (translations ?? [])
.map(({ id }) => [`__lp_${id}`, `__lp-${languageId}_${id}`])
.reduce((r, t) => [...r, ...t], []);
}
/* This list is also maintained by the Marketplace team.
* Remember to reach out to them when adding new domains.
*/
const TrustedSVGSources = [
'api.bintray.com',
'api.travis-ci.com',
'api.travis-ci.org',
'app.fossa.io',
'badge.buildkite.com',
'badge.fury.io',
'badge.waffle.io',
'badgen.net',
'badges.frapsoft.com',
'badges.gitter.im',
'badges.greenkeeper.io',
'cdn.travis-ci.com',
'cdn.travis-ci.org',
'ci.appveyor.com',
'circleci.com',
'cla.opensource.microsoft.com',
'codacy.com',
'codeclimate.com',
'codecov.io',
'coveralls.io',
'david-dm.org',
'deepscan.io',
'dev.azure.com',
'docs.rs',
'flat.badgen.net',
'gemnasium.com',
'githost.io',
'gitlab.com',
'godoc.org',
'goreportcard.com',
'img.shields.io',
'isitmaintained.com',
'marketplace.visualstudio.com',
'nodesecurity.io',
'opencollective.com',
'snyk.io',
'travis-ci.com',
'travis-ci.org',
'visualstudio.com',
'vsmarketplacebadge.apphb.com',
'www.bithound.io',
'www.versioneye.com',
];
function isGitHubRepository(repository) {
return /^https:\/\/github\.com\/|^git@github\.com:/.test(repository ?? '');
}
function isGitLabRepository(repository) {
return /^https:\/\/gitlab\.com\/|^git@gitlab\.com:/.test(repository ?? '');
}
function isGitHubBadge(href) {
return /^https:\/\/github\.com\/[^/]+\/[^/]+\/(actions\/)?workflows\/.*badge\.svg/.test(href || '');
}
function isHostTrusted(url) {
return (url.host && TrustedSVGSources.indexOf(url.host.toLowerCase()) > -1) || isGitHubBadge(url.href);
}
async function versionBump(options) {
if (!options.version) {
return;
}
if (!(options.updatePackageJson ?? true)) {
return;
}
const cwd = options.cwd ?? process.cwd();
const manifest = await readManifest(cwd);
if (manifest.version === options.version) {
return;
}
switch (options.version) {
case 'major':
case 'minor':
case 'patch':
break;
case 'premajor':
case 'preminor':
case 'prepatch':
case 'prerelease':
case 'from-git':
return Promise.reject(`Not supported: ${options.version}`);
default:
if (!semver.valid(options.version)) {
return Promise.reject(`Invalid version ${options.version}`);
}
}
let command = `npm version ${options.version}`;
if (options.commitMessage) {
command = `${command} -m "${options.commitMessage}"`;
}
if (!(options.gitTagVersion ?? true)) {
command = `${command} --no-git-tag-version`;
}
// call `npm version` to do our dirty work
const { stdout, stderr } = await (0, util_1.promisify)(cp.exec)(command, { cwd });
if (!process.env['VSCE_TESTS']) {
process.stdout.write(stdout);
process.stderr.write(stderr);
}
}
exports.versionBump = versionBump;
exports.Targets = new Set([
'win32-x64',
'win32-ia32',
'win32-arm64',
'linux-x64',
'linux-arm64',
'linux-armhf',
'darwin-x64',
'darwin-arm64',
'alpine-x64',
'alpine-arm64',
'web',
]);
class ManifestProcessor extends BaseProcessor {
constructor(manifest, options = {}) {
super(manifest);
this.options = options;
const flags = ['Public'];
if (manifest.preview) {
flags.push('Preview');
}
const gitHost = getGitHost(manifest);
const repository = getRepositoryUrl(manifest, gitHost);
const isGitHub = isGitHubRepository(repository);
let enableMarketplaceQnA;
let customerQnALink;
if (manifest.qna === 'marketplace') {
enableMarketplaceQnA = true;
}
else if (typeof manifest.qna === 'string') {
customerQnALink = manifest.qna;
}
else if (manifest.qna === false) {
enableMarketplaceQnA = false;
}
const extensionKind = getExtensionKind(manifest);
const target = options.target;
const preRelease = options.preRelease;
if (target || preRelease) {
let engineVersion;
try {
const engineSemver = (0, parse_semver_1.default)(`vscode@${manifest.engines['vscode']}`);
engineVersion = engineSemver.version;
}
catch (err) {
throw new Error('Failed to parse semver of engines.vscode');
}
if (target) {
if (engineVersion !== 'latest' && !semver.satisfies(engineVersion, '>=1.61', { includePrerelease: true })) {
throw new Error(`Platform specific extension is supported by VS Code >=1.61. Current 'engines.vscode' is '${manifest.engines['vscode']}'.`);
}
if (!exports.Targets.has(target)) {
throw new Error(`'${target}' is not a valid VS Code target. Valid targets: ${[...exports.Targets].join(', ')}`);
}
}
if (preRelease) {
if (engineVersion !== 'latest' && !semver.satisfies(engineVersion, '>=1.63', { includePrerelease: true })) {
throw new Error(`Pre-release versions are supported by VS Code >=1.63. Current 'engines.vscode' is '${manifest.engines['vscode']}'.`);
}
}
}
this.vsix = {
...this.vsix,
id: manifest.name,
displayName: manifest.displayName ?? manifest.name,
version: options.version && !(options.updatePackageJson ?? true) ? options.version : manifest.version,
publisher: manifest.publisher,
target,
engine: manifest.engines['vscode'],
description: manifest.description ?? '',
pricing: manifest.pricing ?? 'Free',
categories: (manifest.categories ?? []).join(','),
flags: flags.join(' '),
links: {
repository,
bugs: getBugsUrl(manifest, gitHost),
homepage: getHomepageUrl(manifest, gitHost),
},
galleryBanner: manifest.galleryBanner ?? {},
badges: manifest.badges,
githubMarkdown: manifest.markdown !== 'standard',
enableMarketplaceQnA,
customerQnALink,
extensionDependencies: [...new Set(manifest.extensionDependencies ?? [])].join(','),
extensionPack: [...new Set(manifest.extensionPack ?? [])].join(','),
extensionKind: extensionKind.join(','),
localizedLanguages: manifest.contributes && manifest.contributes.localizations
? manifest.contributes.localizations
.map(loc => loc.localizedLanguageName ?? loc.languageName ?? loc.languageId)
.join(',')
: '',
preRelease: !!this.options.preRelease,
sponsorLink: manifest.sponsor?.url || '',
};
if (isGitHub) {
this.vsix.links.github = repository;
}
}
async onFile(file) {
const path = util.normalize(file.path);
if (!/^extension\/package.json$/i.test(path)) {
return Promise.resolve(file);
}
if (this.options.version && !(this.options.updatePackageJson ?? true)) {
const contents = await read(file);
const packageJson = JSON.parse(contents);
packageJson.version = this.options.version;
file = { ...file, contents: JSON.stringify(packageJson, undefined, 2) };
}
// Ensure that package.json is writable as VS Code needs to
// store metadata in the extracted file.
return { ...file, mode: 0o100644 };
}
async onEnd() {
if (typeof this.manifest.extensionKind === 'string') {
util.log.warn(`The 'extensionKind' property should be of type 'string[]'. Learn more at: https://aka.ms/vscode/api/incorrect-execution-location`);
}
if (this.manifest.publisher === 'vscode-samples') {
throw new Error("It's not allowed to use the 'vscode-samples' publisher. Learn more at: https://code.visualstudio.com/api/working-with-extensions/publishing-extension.");
}
if (!this.options.allowMissingRepository && !this.manifest.repository) {
util.log.warn(`A 'repository' field is missing from the 'package.json' manifest file.`);
if (!/^y$/i.test(await util.read('Do you want to continue? [y/N] '))) {
throw new Error('Aborted');
}
}
if (!this.options.allowStarActivation && this.manifest.activationEvents?.some(e => e === '*')) {
util.log.warn(`Using '*' activation is usually a bad idea as it impacts performance.\nMore info: https://code.visualstudio.com/api/references/activation-events#Start-up`);
if (!/^y$/i.test(await util.read('Do you want to continue? [y/N] '))) {
throw new Error('Aborted');
}
}
}
}
exports.ManifestProcessor = ManifestProcessor;
class TagsProcessor extends BaseProcessor {
async onEnd() {
const keywords = this.manifest.keywords ?? [];
const contributes = this.manifest.contributes;
const activationEvents = this.manifest.activationEvents ?? [];
const doesContribute = (...properties) => {
let obj = contributes;
for (const property of properties) {
if (!obj) {
return false;
}
obj = obj[property];
}
return obj && obj.length > 0;
};
const colorThemes = doesContribute('themes') ? ['theme', 'color-theme'] : [];
const iconThemes = doesContribute('iconThemes') ? ['theme', 'icon-theme'] : [];
const productIconThemes = doesContribute('productIconThemes') ? ['theme', 'product-icon-theme'] : [];
const snippets = doesContribute('snippets') ? ['snippet'] : [];
const keybindings = doesContribute('keybindings') ? ['keybindings'] : [];
const debuggers = doesContribute('debuggers') ? ['debuggers'] : [];
const json = doesContribute('jsonValidation') ? ['json'] : [];
const remoteMenu = doesContribute('menus', 'statusBar/remoteIndicator') ? ['remote-menu'] : [];
const localizationContributions = ((contributes && contributes['localizations']) ?? []).reduce((r, l) => [...r, `lp-${l.languageId}`, ...toLanguagePackTags(l.translations, l.languageId)], []);
const languageContributions = ((contributes && contributes['languages']) ?? []).reduce((r, l) => [...r, l.id, ...(l.aliases ?? []), ...toExtensionTags(l.extensions ?? [])], []);
const languageActivations = activationEvents
.map(e => /^onLanguage:(.*)$/.exec(e))
.filter(util.nonnull)
.map(r => r[1]);
const grammars = ((contributes && contributes['grammars']) ?? []).map(g => g.language);
const description = this.manifest.description || '';
const descriptionKeywords = Object.keys(TagsProcessor.Keywords).reduce((r, k) => r.concat(new RegExp('\\b(?:' + escapeRegExp(k) + ')(?!\\w)', 'gi').test(description) ? TagsProcessor.Keywords[k] : []), []);
const webExtensionTags = isWebKind(this.manifest) ? ['__web_extension'] : [];
const sponsorTags = this.manifest.sponsor?.url ? ['__sponsor_extension'] : [];
const tags = new Set([
...keywords,
...colorThemes,
...iconThemes,
...productIconThemes,
...snippets,
...keybindings,
...debuggers,
...json,
...remoteMenu,
...localizationContributions,
...languageContributions,
...languageActivations,
...grammars,
...descriptionKeywords,
...webExtensionTags,
...sponsorTags,
]);
this.tags = [...tags].filter(tag => !!tag);
}
}
exports.TagsProcessor = TagsProcessor;
TagsProcessor.Keywords = {
git: ['git'],
npm: ['node'],
spell: ['markdown'],
bootstrap: ['bootstrap'],
lint: ['linters'],
linting: ['linters'],
react: ['javascript'],
js: ['javascript'],
node: ['javascript', 'node'],
'c++': ['c++'],
Cplusplus: ['c++'],
xml: ['xml'],
angular: ['javascript'],
jquery: ['javascript'],
php: ['php'],
python: ['python'],
latex: ['latex'],
ruby: ['ruby'],
java: ['java'],
erlang: ['erlang'],
sql: ['sql'],
nodejs: ['node'],
'c#': ['c#'],
css: ['css'],
javascript: ['javascript'],
ftp: ['ftp'],
haskell: ['haskell'],
unity: ['unity'],
terminal: ['terminal'],
powershell: ['powershell'],
laravel: ['laravel'],
meteor: ['meteor'],
emmet: ['emmet'],
eslint: ['linters'],
tfs: ['tfs'],
rust: ['rust'],
};
class MarkdownProcessor extends BaseProcessor {
constructor(manifest, name, regexp, assetType, options = {}) {
super(manifest);
this.name = name;
this.regexp = regexp;
this.assetType = assetType;
const guess = this.guessBaseUrls(options.githubBranch || options.gitlabBranch);
this.baseContentUrl = options.baseContentUrl || (guess && guess.content);
this.baseImagesUrl = options.baseImagesUrl || options.baseContentUrl || (guess && guess.images);
this.rewriteRelativeLinks = options.rewriteRelativeLinks ?? true;
this.repositoryUrl = guess && guess.repository;
this.isGitHub = isGitHubRepository(this.repositoryUrl);
this.isGitLab = isGitLabRepository(this.repositoryUrl);
this.gitHubIssueLinking = typeof options.gitHubIssueLinking === 'boolean' ? options.gitHubIssueLinking : true;
this.gitLabIssueLinking = typeof options.gitLabIssueLinking === 'boolean' ? options.gitLabIssueLinking : true;
}
async onFile(file) {
const filePath = util.normalize(file.path);
if (!this.regexp.test(filePath)) {
return Promise.resolve(file);
}
this.assets.push({ type: this.assetType, path: filePath });
let contents = await read(file);
if (/This is the README for your extension /.test(contents)) {
throw new Error(`Make sure to edit the README.md file before you package or publish your extension.`);
}
if (this.rewriteRelativeLinks) {
const markdownPathRegex = /(!?)\[([^\]\[]*|!\[[^\]\[]*]\([^\)]+\))\]\(([^\)]+)\)/g;
const urlReplace = (_, isImage, title, link) => {
if (/^mailto:/i.test(link)) {
return `${isImage}[${title}](${link})`;
}
const isLinkRelative = !/^\w+:\/\//.test(link) && link[0] !== '#';
if (!this.baseContentUrl && !this.baseImagesUrl) {
const asset = isImage ? 'image' : 'link';
if (isLinkRelative) {
throw new Error(`Couldn't detect the repository where this extension is published. The ${asset} '${link}' will be broken in ${this.name}. GitHub/GitLab repositories will be automatically detected. Otherwise, please provide the repository URL in package.json or use the --baseContentUrl and --baseImagesUrl options.`);
}
}
title = title.replace(markdownPathRegex, urlReplace);
const prefix = isImage ? this.baseImagesUrl : this.baseContentUrl;
if (!prefix || !isLinkRelative) {
return `${isImage}[${title}](${link})`;
}
return `${isImage}[${title}](${(0, url_join_1.default)(prefix, path.posix.normalize(link))})`;
};
// Replace Markdown links with urls
contents = contents.replace(markdownPathRegex, urlReplace);
// Replace <img> links with urls
contents = contents.replace(/<img.+?src=["']([/.\w\s#-]+)['"].*?>/g, (all, link) => {
const isLinkRelative = !/^\w+:\/\//.test(link) && link[0] !== '#';
if (!this.baseImagesUrl && isLinkRelative) {
throw new Error(`Couldn't detect the repository where this extension is published. The image will be broken in ${this.name}. GitHub/GitLab repositories will be automatically detected. Otherwise, please provide the repository URL in package.json or use the --baseContentUrl and --baseImagesUrl options.`);
}
const prefix = this.baseImagesUrl;
if (!prefix || !isLinkRelative) {
return all;
}
return all.replace(link, (0, url_join_1.default)(prefix, path.posix.normalize(link)));
});
if ((this.gitHubIssueLinking && this.isGitHub) || (this.gitLabIssueLinking && this.isGitLab)) {
const markdownIssueRegex = /(\s|\n)([\w\d_-]+\/[\w\d_-]+)?#(\d+)\b/g;
const issueReplace = (all, prefix, ownerAndRepositoryName, issueNumber) => {
let result = all;
let owner;
let repositoryName;
if (ownerAndRepositoryName) {
[owner, repositoryName] = ownerAndRepositoryName.split('/', 2);
}
if (owner && repositoryName && issueNumber) {
// Issue in external repository
const issueUrl = this.isGitHub
? (0, url_join_1.default)('https://github.com', owner, repositoryName, 'issues', issueNumber)
: (0, url_join_1.default)('https://gitlab.com', owner, repositoryName, '-', 'issues', issueNumber);
result = prefix + `[${owner}/${repositoryName}#${issueNumber}](${issueUrl})`;
}
else if (!owner && !repositoryName && issueNumber && this.repositoryUrl) {
// Issue in own repository
result =
prefix +
`[#${issueNumber}](${this.isGitHub
? (0, url_join_1.default)(this.repositoryUrl, 'issues', issueNumber)
: (0, url_join_1.default)(this.repositoryUrl, '-', 'issues', issueNumber)})`;
}
return result;
};
// Replace Markdown issue references with urls
contents = contents.replace(markdownIssueRegex, issueReplace);
}
}
const html = (0, markdown_it_1.default)({ html: true }).render(contents);
const $ = cheerio.load(html);
if (this.rewriteRelativeLinks) {
$('img').each((_, img) => {
const rawSrc = $(img).attr('src');
if (!rawSrc) {
throw new Error(`Images in ${this.name} must have a source.`);
}
const src = decodeURI(rawSrc);
const srcUrl = new url.URL(src);
if (/^data:$/i.test(srcUrl.protocol) && /^image$/i.test(srcUrl.host) && /\/svg/i.test(srcUrl.pathname)) {
throw new Error(`SVG data URLs are not allowed in ${this.name}: ${src}`);
}
if (!/^https:$/i.test(srcUrl.protocol)) {
throw new Error(`Images in ${this.name} must come from an HTTPS source: ${src}`);
}
if (/\.svg$/i.test(srcUrl.pathname) && !isHostTrusted(srcUrl)) {
throw new Error(`SVGs are restricted in ${this.name}; please use other file image formats, such as PNG: ${src}`);
}
});
}
$('svg').each(() => {
throw new Error(`SVG tags are not allowed in ${this.name}.`);
});
return {
path: file.path,
contents: Buffer.from(contents, 'utf8'),
};
}
// GitHub heuristics
guessBaseUrls(githostBranch) {
let repository = null;
if (typeof this.manifest.repository === 'string') {
repository = this.manifest.repository;
}
else if (this.manifest.repository && typeof this.manifest.repository['url'] === 'string') {
repository = this.manifest.repository['url'];
}
if (!repository) {
return undefined;
}
const gitHubRegex = /(?<domain>github(\.com\/|:))(?<project>(?:[^/]+)\/(?:[^/]+))(\/|$)/;
const gitLabRegex = /(?<domain>gitlab(\.com\/|:))(?<project>(?:[^/]+)(\/(?:[^/]+))+)(\/|$)/;
const match = (gitHubRegex.exec(repository) || gitLabRegex.exec(repository));
if (!match) {
return undefined;
}
const project = match.groups.project.replace(/\.git$/i, '');
const branchName = githostBranch ? githostBranch : 'HEAD';
if (/^github/.test(match.groups.domain)) {
return {
content: `https://github.com/${project}/blob/${branchName}`,
images: `https://github.com/${project}/raw/${branchName}`,
repository: `https://github.com/${project}`,
};
}
else if (/^gitlab/.test(match.groups.domain)) {
return {
content: `https://gitlab.com/${project}/-/blob/${branchName}`,
images: `https://gitlab.com/${project}/-/raw/${branchName}`,
repository: `https://gitlab.com/${project}`,
};
}
return undefined;
}
}
exports.MarkdownProcessor = MarkdownProcessor;
class ReadmeProcessor extends MarkdownProcessor {
constructor(manifest, options = {}) {
super(manifest, 'README.md', /^extension\/readme.md$/i, 'Microsoft.VisualStudio.Services.Content.Details', options);
}
}
exports.ReadmeProcessor = ReadmeProcessor;
class ChangelogProcessor extends MarkdownProcessor {
constructor(manifest, options = {}) {
super(manifest, 'CHANGELOG.md', /^extension\/changelog.md$/i, 'Microsoft.VisualStudio.Services.Content.Changelog', options);
}
}
exports.ChangelogProcessor = ChangelogProcessor;
class LicenseProcessor extends BaseProcessor {
constructor(manifest) {
super(manifest);
this.didFindLicense = false;
const match = /^SEE LICENSE IN (.*)$/.exec(manifest.license || '');
if (!match || !match[1]) {
this.expectedLicenseName = 'LICENSE.md, LICENSE.txt or LICENSE';
this.filter = name => /^extension\/license(\.(md|txt))?$/i.test(name);
}
else {
this.expectedLicenseName = match[1];
const regexp = new RegExp('^extension/' + match[1] + '$');
this.filter = regexp.test.bind(regexp);
}
delete this.vsix.license;
}
onFile(file) {
if (!this.didFindLicense) {
let normalizedPath = util.normalize(file.path);
if (this.filter(normalizedPath)) {
if (!path.extname(normalizedPath)) {
file.path += '.txt';
normalizedPath += '.txt';
}
this.assets.push({ type: 'Microsoft.VisualStudio.Services.Content.License', path: normalizedPath });
this.vsix.license = normalizedPath;
this.didFindLicense = true;
}
}
return Promise.resolve(file);
}
async onEnd() {
if (!this.didFindLicense) {
util.log.warn(`${this.expectedLicenseName} not found`);
if (!/^y$/i.test(await util.read('Do you want to continue? [y/N] '))) {
throw new Error('Aborted');
}
}
}
}
class LaunchEntryPointProcessor extends BaseProcessor {
constructor(manifest) {
super(manifest);
this.entryPoints = new Set();
if (manifest.main) {
this.entryPoints.add(util.normalize(path.join('extension', this.appendJSExt(manifest.main))));
}
if (manifest.browser) {
this.entryPoints.add(util.normalize(path.join('extension', this.appendJSExt(manifest.browser))));
}
}
appendJSExt(filePath) {
if (filePath.endsWith('.js')) {
return filePath;
}
return filePath + '.js';
}
onFile(file) {
this.entryPoints.delete(util.normalize(file.path));
return Promise.resolve(file);
}
async onEnd() {
if (this.entryPoints.size > 0) {
const files = [...this.entryPoints].join(',\n ');
throw new Error(`Extension entrypoint(s) missing. Make sure these files exist and aren't ignored by '.vscodeignore':\n ${files}`);
}
}
}
class IconProcessor extends BaseProcessor {
constructor(manifest) {
super(manifest);
this.didFindIcon = false;
this.icon = manifest.icon && `extension/${manifest.icon}`;
delete this.vsix.icon;
}
onFile(file) {
const normalizedPath = util.normalize(file.path);
if (normalizedPath === this.icon) {
this.didFindIcon = true;
this.assets.push({ type: 'Microsoft.VisualStudio.Services.Icons.Default', path: normalizedPath });
this.vsix.icon = this.icon;
}
return Promise.resolve(file);
}
async onEnd() {
if (this.icon && !this.didFindIcon) {
return Promise.reject(new Error(`The specified icon '${this.icon}' wasn't found in the extension.`));
}
}
}
const ValidExtensionKinds = new Set(['ui', 'workspace']);
function isWebKind(manifest) {
const extensionKind = getExtensionKind(manifest);
return extensionKind.some(kind => kind === 'web');
}
exports.isWebKind = isWebKind;
const extensionPointExtensionKindsMap = new Map();
extensionPointExtensionKindsMap.set('jsonValidation', ['workspace', 'web']);
extensionPointExtensionKindsMap.set('localizations', ['ui', 'workspace']);
extensionPointExtensionKindsMap.set('debuggers', ['workspace']);
extensionPointExtensionKindsMap.set('terminal', ['workspace']);
extensionPointExtensionKindsMap.set('typescriptServerPlugins', ['workspace']);
extensionPointExtensionKindsMap.set('markdown.previewStyles', ['workspace', 'web']);
extensionPointExtensionKindsMap.set('markdown.previewScripts', ['workspace', 'web']);
extensionPointExtensionKindsMap.set('markdown.markdownItPlugins', ['workspace', 'web']);
extensionPointExtensionKindsMap.set('html.customData', ['workspace', 'web']);
extensionPointExtensionKindsMap.set('css.customData', ['workspace', 'web']);
function getExtensionKind(manifest) {
const deduced = deduceExtensionKinds(manifest);
// check the manifest
if (manifest.extensionKind) {
const result = Array.isArray(manifest.extensionKind)
? manifest.extensionKind
: manifest.extensionKind === 'ui'
? ['ui', 'workspace']
: [manifest.extensionKind];
// Add web kind if the extension can run as web extension
if (deduced.includes('web') && !result.includes('web')) {
result.push('web');
}
return result;
}
return deduced;
}
function deduceExtensionKinds(manifest) {
// Not an UI extension if it has main
if (manifest.main) {
if (manifest.browser) {
return ['workspace', 'web'];
}
return ['workspace'];
}
if (manifest.browser) {
return ['web'];
}
let result = ['ui', 'workspace', 'web'];
const isNonEmptyArray = (obj) => Array.isArray(obj) && obj.length > 0;
// Extension pack defaults to workspace,web extensionKind
if (isNonEmptyArray(manifest.extensionPack) || isNonEmptyArray(manifest.extensionDependencies)) {
result = ['workspace', 'web'];
}
if (manifest.contributes) {
for (const contribution of Object.keys(manifest.contributes)) {
const supportedExtensionKinds = extensionPointExtensionKindsMap.get(contribution);
if (supportedExtensionKinds) {
result = result.filter(extensionKind => supportedExtensionKinds.indexOf(extensionKind) !== -1);
}
}
}
return result;
}
class NLSProcessor extends BaseProcessor {
constructor(manifest) {
super(manifest);
this.translations = Object.create(null);
if (!manifest.contributes ||
!manifest.contributes.localizations ||
manifest.contributes.localizations.length === 0) {
return;
}
const localizations = manifest.contributes.localizations;
const translations = Object.create(null);
// take last reference in the manifest for any given language
for (const localization of localizations) {
for (const translation of localization.translations) {
if (translation.id === 'vscode' && !!translation.path) {
const translationPath = util.normalize(translation.path.replace(/^\.[\/\\]/, ''));
translations[localization.languageId.toUpperCase()] = `extension/${translationPath}`;
}
}
}
// invert the map for later easier retrieval
for (const languageId of Object.keys(translations)) {
this.translations[translations[languageId]] = languageId;
}
}
onFile(file) {
const normalizedPath = util.normalize(file.path);
const language = this.translations[normalizedPath];
if (language) {
this.assets.push({ type: `Microsoft.VisualStudio.Code.Translation.${language}`, path: normalizedPath });
}
return Promise.resolve(file);
}
}
exports.NLSProcessor = NLSProcessor;
class ValidationProcessor extends BaseProcessor {
constructor() {
super(...arguments);
this.files = new Map();
this.duplicates = new Set();
}
async onFile(file) {
const lower = file.path.toLowerCase();
const existing = this.files.get(lower);
if (existing) {
this.duplicates.add(lower);
existing.push(file.path);
}
else {
this.files.set(lower, [file.path]);
}
return file;
}
async onEnd() {
if (this.duplicates.size === 0) {
return;
}
const messages = [
`The following files have the same case insensitive path, which isn't supported by the VSIX format:`,
];
for (const lower of this.duplicates) {
for (const filePath of this.files.get(lower)) {
messages.push(` - ${filePath}`);
}
}
throw new Error(messages.join('\n'));
}
}
exports.ValidationProcessor = ValidationProcessor;
function validateManifest(manifest) {
(0, validation_1.validateExtensionName)(manifest.name);
if (!manifest.version) {
throw new Error('Manifest missing field: version');
}
if (manifest.pricing && !['Free', 'Trial'].includes(manifest.pricing)) {
throw new Error('Pricing should be Free or Trial');
}
(0, validation_1.validateVersion)(manifest.version);
if (!manifest.engines) {
throw new Error('Manifest missing field: engines');
}
if (!manifest.engines['vscode']) {
throw new Error('Manifest missing field: engines.vscode');
}
(0, validation_1.validateEngineCompatibility)(manifest.engines['vscode']);
const hasActivationEvents = !!manifest.activationEvents;
const hasMain = !!manifest.main;
const hasBrowser = !!manifest.browser;
if (hasActivationEvents) {
if (!hasMain && !hasBrowser) {
throw new Error("Manifest needs either a 'main' or 'browser' property, given it has a 'activationEvents' property.");
}
}
else if (hasMain) {
throw new Error("Manifest needs the 'activationEvents' property, given it has a 'main' property.");
}
else if (hasBrowser) {
throw new Error("Manifest needs the 'activationEvents' property, given it has a 'browser' property.");
}
if (manifest.devDependencies && manifest.devDependencies['@types/vscode']) {
(0, validation_1.validateVSCodeTypesCompatibility)(manifest.engines['vscode'], manifest.devDependencies['@types/vscode']);
}
if (/\.svg$/i.test(manifest.icon || '')) {
throw new Error(`SVGs can't be used as icons: ${manifest.icon}`);
}
(manifest.badges ?? []).forEach(badge => {
const decodedUrl = decodeURI(badge.url);
const srcUrl = new url.URL(decodedUrl);
if (!/^https:$/i.test(srcUrl.protocol)) {
throw new Error(`Badge URLs must come from an HTTPS source: ${badge.url}`);
}
if (/\.svg$/i.test(srcUrl.pathname) && !isHostTrusted(srcUrl)) {
throw new Error(`Badge SVGs are restricted. Please use other file image formats, such as PNG: ${badge.url}`);
}
});
Object.keys(manifest.dependencies || {}).forEach(dep => {
if (dep === 'vscode') {
throw new Error(`You should not depend on 'vscode' in your 'dependencies'. Did you mean to add it to 'devDependencies'?`);
}
});
if (manifest.extensionKind) {
const extensionKinds = Array.isArray(manifest.extensionKind) ? manifest.extensionKind : [manifest.extensionKind];
for (const kind of extensionKinds) {
if (!ValidExtensionKinds.has(kind)) {
throw new Error(`Manifest contains invalid value '${kind}' in the 'extensionKind' property. Allowed values are ${[
...ValidExtensionKinds,
]
.map(k => `'${k}'`)
.join(', ')}.`);
}
}
}
if (manifest.sponsor) {
let isValidSponsorUrl = true;
try {
const sponsorUrl = new url.URL(manifest.sponsor.url);
isValidSponsorUrl = /^(https|http):$/i.test(sponsorUrl.protocol);
}
catch (error) {
isValidSponsorUrl = false;
}
if (!isValidSponsorUrl) {
throw new Error(`Manifest contains invalid value '${manifest.sponsor.url}' in the 'sponsor' property. It must be a valid URL with a HTTP or HTTPS protocol.`);
}
}
return manifest;
}
exports.validateManifest = validateManifest;
function readManifest(cwd = process.cwd(), nls = true) {
const manifestPath = path.join(cwd, 'package.json');
const manifestNLSPath = path.join(cwd, 'package.nls.json');
const manifest = fs.promises
.readFile(manifestPath, 'utf8')
.catch(() => Promise.reject(`Extension manifest not found: ${manifestPath}`))
.then(manifestStr => {
try {
return Promise.resolve(JSON.parse(manifestStr));
}
catch (e) {
return Promise.reject(`Error parsing 'package.json' manifest file: not a valid JSON file.`);
}
})
.then(validateManifest);
if (!nls) {
return manifest;
}
const manifestNLS = fs.promises
.readFile(manifestNLSPath, 'utf8')
.catch(err => (err.code !== 'ENOENT' ? Promise.reject(err) : Promise.resolve('{}')))
.then(raw => {
try {
return Promise.resolve(JSON.parse(raw));
}
catch (e) {
return Promise.reject(`Error parsing JSON manifest translations file: ${manifestNLSPath}`);
}
});
return Promise.all([manifest, manifestNLS]).then(([manifest, translations]) => {
return (0, nls_1.patchNLS)(manifest, translations);
});
}
exports.readManifest = readManifest;
const escapeChars = new Map([
["'", '''],
['"', '"'],
['<', '<'],
['>', '>'],
['&', '&'],
]);
function escape(value) {
return String(value).replace(/(['"<>&])/g, (_, char) => escapeChars.get(char));
}
async function toVsixManifest(vsix) {
return `<?xml version="1.0" encoding="utf-8"?>
<PackageManifest Version="2.0.0" xmlns="http://schemas.microsoft.com/developer/vsx-schema/2011" xmlns:d="http://schemas.microsoft.com/developer/vsx-schema-design/2011">
<Metadata>
<Identity Language="en-US" Id="${escape(vsix.id)}" Version="${escape(vsix.version)}" Publisher="${escape(vsix.publisher)}" ${vsix.target ? `TargetPlatform="${escape(vsix.target)}"` : ''}/>
<DisplayName>${escape(vsix.displayName)}</DisplayName>
<Description xml:space="preserve">${escape(vsix.description)}</Description>
<Tags>${escape(vsix.tags)}</Tags>
<Categories>${escape(vsix.categories)}</Categories>
<GalleryFlags>${escape(vsix.flags)}</GalleryFlags>
${!vsix.badges
? ''
: `<Badges>${vsix.badges
.map(badge => `<Badge Link="${escape(badge.href)}" ImgUri="${escape(badge.url)}" Description="${escape(badge.description)}" />`)
.join('\n')}</Badges>`}
<Properties>
<Property Id="Microsoft.VisualStudio.Code.Engine" Value="${escape(vsix.engine)}" />
<Property Id="Microsoft.VisualStudio.Code.ExtensionDependencies" Value="${escape(vsix.extensionDependencies)}" />
<Property Id="Microsoft.VisualStudio.Code.ExtensionPack" Value="${escape(vsix.extensionPack)}" />
<Property Id="Microsoft.VisualStudio.Code.ExtensionKind" Value="${escape(vsix.extensionKind)}" />
<Property Id="Microsoft.VisualStudio.Code.LocalizedLanguages" Value="${escape(vsix.localizedLanguages)}" />
${vsix.preRelease ? `<Property Id="Microsoft.VisualStudio.Code.PreRelease" Value="${escape(vsix.preRelease)}" />` : ''}
${vsix.sponsorLink
? `<Property Id="Microsoft.VisualStudio.Code.SponsorLink" Value="${escape(vsix.sponsorLink)}" />`
: ''}
${!vsix.links.repository
? ''
: `<Property Id="Microsoft.VisualStudio.Services.Links.Source" Value="${escape(vsix.links.repository)}" />
<Property Id="Microsoft.VisualStudio.Services.Links.Getstarted" Value="${escape(vsix.links.repository)}" />
${vsix.links.github
? `<Property Id="Microsoft.VisualStudio.Services.Links.GitHub" Value="${escape(vsix.links.github)}" />`
: `<Property Id="Microsoft.VisualStudio.Services.Links.Repository" Value="${escape(vsix.links.repository)}" />`}`}
${vsix.links.bugs
? `<Property Id="Microsoft.VisualStudio.Services.Links.Support" Value="${escape(vsix.links.bugs)}" />`
: ''}
${vsix.links.homepage
? `<Property Id="Microsoft.VisualStudio.Services.Links.Learn" Value="${escape(vsix.links.homepage)}" />`
: ''}
${vsix.galleryBanner.color
? `<Property Id="Microsoft.VisualStudio.Services.Branding.Color" Value="${escape(vsix.galleryBanner.color)}" />`
: ''}
${vsix.galleryBanner.theme
? `<Property Id="Microsoft.VisualStudio.Services.Branding.Theme" Value="${escape(vsix.galleryBanner.theme)}" />`
: ''}
<Property Id="Microsoft.VisualStudio.Services.GitHubFlavoredMarkdown" Value="${escape(vsix.githubMarkdown)}" />
<Property Id="Microsoft.VisualStudio.Services.Content.Pricing" Value="${escape(vsix.pricing)}"/>
${vsix.enableMarketplaceQnA !== undefined
? `<Property Id="Microsoft.VisualStudio.Services.EnableMarketplaceQnA" Value="${escape(vsix.enableMarketplaceQnA)}" />`
: ''}
${vsix.customerQnALink !== undefined
? `<Property Id="Microsoft.VisualStudio.Services.CustomerQnALink" Value="${escape(vsix.customerQnALink)}" />`
: ''}
</Properties>
${vsix.license ? `<License>${escape(vsix.license)}</License>` : ''}
${vsix.icon ? `<Icon>${escape(vsix.icon)}</Icon>` : ''}
</Metadata>
<Installation>
<InstallationTarget Id="Microsoft.VisualStudio.Code"/>
</Installation>
<Dependencies/>
<Assets>
<Asset Type="Microsoft.VisualStudio.Code.Manifest" Path="extension/package.json" Addressable="true" />
${vsix.assets
.map(asset => `<Asset Type="${escape(asset.type)}" Path="${escape(asset.path)}" Addressable="true" />`)
.join('\n')}
</Assets>
</PackageManifest>`;
}
exports.toVsixManifest = toVsixManifest;
const defaultMimetypes = new Map([
['.json', 'application/json'],
['.vsixmanifest', 'text/xml'],
]);
async function toContentTypes(files) {
const mimetypes = new Map(defaultMimetypes);
for (const file of files) {
const ext = path.extname(file.path).toLowerCase();
if (ext) {
mimetypes.set(ext, mime_1.default.lookup(ext));
}
}
const contentTypes = [];
for (const [extension, contentType] of mimetypes) {
contentTypes.push(`<Default Extension="${extension}" ContentType="${contentType}"/>`);
}
return `<?xml version="1.0" encoding="utf-8"?>
<Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types">${contentTypes.join('')}</Types>
`;
}
exports.toContentTypes = toContentTypes;
const defaultIgnore = [
'.vscodeignore',
'package-lock.json',
'npm-debug.log',
'yarn.lock',
'yarn-error.log',
'npm-shrinkwrap.json',
'.editorconfig',
'.npmrc',
'.yarnrc',
'.gitattributes',
'*.todo',
'tslint.yaml',
'.eslintrc*',
'.babelrc*',
'.prettierrc*',
'.cz-config.js',
'.commitlintrc*',
'webpack.config.js',
'ISSUE_TEMPLATE.md',
'CONTRIBUTING.md',
'PULL_REQUEST_TEMPLATE.md',
'CODE_OF_CONDUCT.md',
'.github',
'.travis.yml',
'appveyor.yml',
'**/.git/**',
'**/*.vsix',
'**/.DS_Store',
'**/*.vsixmanifest',
'**/.vscode-test/**',
'**/.vscode-test-web/**',
];
const notIgnored = ['!package.json', '!README.md'];
async function collectAllFiles(cwd, dependencies, dependencyEntryPoints) {
const deps = await (0, npm_1.getDependencies)(cwd, dependencies, dependencyEntryPoints);
const promises = deps.map(dep => (0, util_1.promisify)(glob_1.default)('**', { cwd: dep, nodir: true, dot: true, ignore: 'node_modules/**' }).then(files => files.map(f => path.relative(cwd, path.join(dep, f))).map(f => f.replace(/\\/g, '/'))));
return Promise.all(promises).then(util.flatten);
}
function collectFiles(cwd, dependencies, dependencyEntryPoints, ignoreFile) {
return collectAllFiles(cwd, dependencies, dependencyEntryPoints).then(files => {
files = files.filter(f => !/\r$/m.test(f));
return (fs.promises
.readFile(ignoreFile ? ignoreFile : path.join(cwd, '.vscodeignore'), 'utf8')
.catch(err => err.code !== 'ENOENT' ? Promise.reject(err) : ignoreFile ? Promise.reject(err) : Promise.resolve(''))
// Parse raw ignore by splitting output into lines and filtering out empty lines and comments
.then(rawIgnore => rawIgnore
.split(/[\n\r]/)
.map(s => s.trim())
.filter(s => !!s)
.filter(i => !/^\s*#/.test(i)))
// Add '/**' to possible folder names
.then(ignore => [
...ignore,
...ignore.filter(i => !/(^|\/)[^/]*\*[^/]*$/.test(i)).map(i => (/\/$/.test(i) ? `${i}**` : `${i}/**`)),
])
// Combine with default ignore list
.then(ignore => [...defaultIgnore, ...ignore, ...notIgnored])
// Split into ignore and negate list
.then(ignore => ignore.reduce((r, e) => (!/^\s*!/.test(e) ? [[...r[0], e], r[1]] : [r[0], [...r[1], e]]), [[], []]))
.then(r => ({ ignore: r[0], negate: r[1] }))
// Filter out files
.then(({ ignore, negate }) => files.filter(f => !ignore.some(i => (0, minimatch_1.default)(f, i, MinimatchOptions)) ||
negate.some(i => (0, minimatch_1.default)(f, i.substr(1), MinimatchOptions)))));
});
}
function processFiles(processors, files) {
const processedFiles = files.map(file => util.chain(file, processors, (file, processor) => processor.onFile(file)));
return Promise.all(processedFiles).then(files => {
return util.sequence(processors.map(p => () => p.onEnd())).then(() => {
const assets = processors.reduce((r, p) => [...r, ...p.assets], []);
const tags = [
...processors.reduce((r, p) => {
for (const tag of p.tags) {
if (tag) {
r.add(tag);
}
}
return r;
}, new Set()),
].join(',');
const vsix = processors.reduce((r, p) => ({ ...r, ...p.vsix }), { assets, tags });
return Promise.all([toVsixManifest(vsix), toContentTypes(