@vscode/vsce 2.15.0

package/out/util.js

@@ -0,0 +1,165 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.patchOptionsWithManifest = exports.log = exports.sequence = exports.CancellationToken = exports.isCancelledError = exports.nonnull = exports.flatten = exports.chain = exports.normalize = exports.getPublicGalleryAPI = exports.getSecurityRolesAPI = exports.getGalleryAPI = exports.getHubUrl = exports.getPublishedUrl = exports.read = void 0;
+const util_1 = require("util");
+const read_1 = __importDefault(require("read"));
+const WebApi_1 = require("azure-devops-node-api/WebApi");
+const GalleryApi_1 = require("azure-devops-node-api/GalleryApi");
+const chalk_1 = __importDefault(require("chalk"));
+const publicgalleryapi_1 = require("./publicgalleryapi");
+const os_1 = require("os");
+const __read = (0, util_1.promisify)(read_1.default);
+function read(prompt, options = {}) {
+    if (process.env['VSCE_TESTS'] || !process.stdout.isTTY) {
+        return Promise.resolve('y');
+    }
+    return __read({ prompt, ...options });
+}
+exports.read = read;
+const marketplaceUrl = process.env['VSCE_MARKETPLACE_URL'] || 'https://marketplace.visualstudio.com';
+function getPublishedUrl(extension) {
+    return `${marketplaceUrl}/items?itemName=${extension}`;
+}
+exports.getPublishedUrl = getPublishedUrl;
+function getHubUrl(publisher, name) {
+    return `${marketplaceUrl}/manage/publishers/${publisher}/extensions/${name}/hub`;
+}
+exports.getHubUrl = getHubUrl;
+async function getGalleryAPI(pat) {
+    // from https://github.com/Microsoft/tfs-cli/blob/master/app/exec/extension/default.ts#L287-L292
+    const authHandler = (0, WebApi_1.getBasicHandler)('OAuth', pat);
+    return new GalleryApi_1.GalleryApi(marketplaceUrl, [authHandler]);
+    // const vsoapi = new WebApi(marketplaceUrl, authHandler);
+    // return await vsoapi.getGalleryApi();
+}
+exports.getGalleryAPI = getGalleryAPI;
+async function getSecurityRolesAPI(pat) {
+    const authHandler = (0, WebApi_1.getBasicHandler)('OAuth', pat);
+    const vsoapi = new WebApi_1.WebApi(marketplaceUrl, authHandler);
+    return await vsoapi.getSecurityRolesApi();
+}
+exports.getSecurityRolesAPI = getSecurityRolesAPI;
+function getPublicGalleryAPI() {
+    return new publicgalleryapi_1.PublicGalleryAPI(marketplaceUrl, '3.0-preview.1');
+}
+exports.getPublicGalleryAPI = getPublicGalleryAPI;
+function normalize(path) {
+    return path.replace(/\\/g, '/');
+}
+exports.normalize = normalize;
+function chain2(a, b, fn, index = 0) {
+    if (index >= b.length) {
+        return Promise.resolve(a);
+    }
+    return fn(a, b[index]).then(a => chain2(a, b, fn, index + 1));
+}
+function chain(initial, processors, process) {
+    return chain2(initial, processors, process);
+}
+exports.chain = chain;
+function flatten(arr) {
+    return [].concat.apply([], arr);
+}
+exports.flatten = flatten;
+function nonnull(arg) {
+    return !!arg;
+}
+exports.nonnull = nonnull;
+const CancelledError = 'Cancelled';
+function isCancelledError(error) {
+    return error === CancelledError;
+}
+exports.isCancelledError = isCancelledError;
+class CancellationToken {
+    constructor() {
+        this.listeners = [];
+        this._cancelled = false;
+    }
+    get isCancelled() {
+        return this._cancelled;
+    }
+    subscribe(fn) {
+        this.listeners.push(fn);
+        return () => {
+            const index = this.listeners.indexOf(fn);
+            if (index > -1) {
+                this.listeners.splice(index, 1);
+            }
+        };
+    }
+    cancel() {
+        const emit = !this._cancelled;
+        this._cancelled = true;
+        if (emit) {
+            this.listeners.forEach(l => l(CancelledError));
+            this.listeners = [];
+        }
+    }
+}
+exports.CancellationToken = CancellationToken;
+async function sequence(promiseFactories) {
+    for (const factory of promiseFactories) {
+        await factory();
+    }
+}
+exports.sequence = sequence;
+var LogMessageType;
+(function (LogMessageType) {
+    LogMessageType[LogMessageType["DONE"] = 0] = "DONE";
+    LogMessageType[LogMessageType["INFO"] = 1] = "INFO";
+    LogMessageType[LogMessageType["WARNING"] = 2] = "WARNING";
+    LogMessageType[LogMessageType["ERROR"] = 3] = "ERROR";
+})(LogMessageType || (LogMessageType = {}));
+const LogPrefix = {
+    [LogMessageType.DONE]: chalk_1.default.bgGreen.black(' DONE '),
+    [LogMessageType.INFO]: chalk_1.default.bgBlueBright.black(' INFO '),
+    [LogMessageType.WARNING]: chalk_1.default.bgYellow.black(' WARNING '),
+    [LogMessageType.ERROR]: chalk_1.default.bgRed.black(' ERROR '),
+};
+function _log(type, msg, ...args) {
+    args = [LogPrefix[type], msg, ...args];
+    if (type === LogMessageType.WARNING) {
+        process.env['GITHUB_ACTIONS'] ? logToGitHubActions('warning', msg) : console.warn(...args);
+    }
+    else if (type === LogMessageType.ERROR) {
+        process.env['GITHUB_ACTIONS'] ? logToGitHubActions('error', msg) : console.error(...args);
+    }
+    else {
+        process.env['GITHUB_ACTIONS'] ? logToGitHubActions('info', msg) : console.log(...args);
+    }
+}
+const EscapeCharacters = new Map([
+    ['%', '%25'],
+    ['\r', '%0D'],
+    ['\n', '%0A'],
+]);
+const EscapeRegex = new RegExp(`[${[...EscapeCharacters.keys()].join('')}]`, 'g');
+function escapeGitHubActionsMessage(message) {
+    return message.replace(EscapeRegex, c => EscapeCharacters.get(c) ?? c);
+}
+function logToGitHubActions(type, message) {
+    const command = type === 'info' ? message : `::${type}::${escapeGitHubActionsMessage(message)}`;
+    process.stdout.write(command + os_1.EOL);
+}
+exports.log = {
+    done: _log.bind(null, LogMessageType.DONE),
+    info: _log.bind(null, LogMessageType.INFO),
+    warn: _log.bind(null, LogMessageType.WARNING),
+    error: _log.bind(null, LogMessageType.ERROR),
+};
+function patchOptionsWithManifest(options, manifest) {
+    if (!manifest.vsce) {
+        return;
+    }
+    for (const key of Object.keys(manifest.vsce)) {
+        const optionsKey = key === 'yarn' ? 'useYarn' : key;
+        if (options[optionsKey] === undefined) {
+            options[optionsKey] = manifest.vsce[key];
+        }
+    }
+}
+exports.patchOptionsWithManifest = patchOptionsWithManifest;
+//# sourceMappingURL=util.js.map

package/out/validation.js

@@ -0,0 +1,120 @@
+"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.validateVSCodeTypesCompatibility = exports.validateEngineCompatibility = exports.validateVersion = exports.validateExtensionName = exports.validatePublisher = void 0;
+const semver = __importStar(require("semver"));
+const parse_semver_1 = __importDefault(require("parse-semver"));
+const nameRegex = /^[a-z0-9][a-z0-9\-]*$/i;
+function validatePublisher(publisher) {
+    if (!publisher) {
+        throw new Error(`Missing publisher name. Learn more: https://code.visualstudio.com/api/working-with-extensions/publishing-extension#publishing-extensions`);
+    }
+    if (!nameRegex.test(publisher)) {
+        throw new Error(`Invalid publisher name '${publisher}'. Expected the identifier of a publisher, not its human-friendly name.  Learn more: https://code.visualstudio.com/api/working-with-extensions/publishing-extension#publishing-extensions`);
+    }
+}
+exports.validatePublisher = validatePublisher;
+function validateExtensionName(name) {
+    if (!name) {
+        throw new Error(`Missing extension name`);
+    }
+    if (!nameRegex.test(name)) {
+        throw new Error(`Invalid extension name '${name}'`);
+    }
+}
+exports.validateExtensionName = validateExtensionName;
+function validateVersion(version) {
+    if (!version) {
+        throw new Error(`Missing extension version`);
+    }
+    if (!semver.valid(version)) {
+        throw new Error(`Invalid extension version '${version}'`);
+    }
+}
+exports.validateVersion = validateVersion;
+function validateEngineCompatibility(version) {
+    if (!version) {
+        throw new Error(`Missing vscode engine compatibility version`);
+    }
+    if (!/^\*$|^(\^|>=)?((\d+)|x)\.((\d+)|x)\.((\d+)|x)(\-.*)?$/.test(version)) {
+        throw new Error(`Invalid vscode engine compatibility version '${version}'`);
+    }
+}
+exports.validateEngineCompatibility = validateEngineCompatibility;
+/**
+ * User shouldn't use a newer version of @types/vscode than the one specified in engines.vscode
+ *
+ * NOTE: This is enforced at the major and minor level. Since we don't have control over the patch
+ * version (it's auto-incremented by DefinitelyTyped), we don't look at the patch version at all.
+ */
+function validateVSCodeTypesCompatibility(engineVersion, typeVersion) {
+    if (engineVersion === '*') {
+        return;
+    }
+    if (!typeVersion) {
+        throw new Error(`Missing @types/vscode version`);
+    }
+    let plainEngineVersion, plainTypeVersion;
+    try {
+        const engineSemver = (0, parse_semver_1.default)(`vscode@${engineVersion}`);
+        plainEngineVersion = engineSemver.version;
+    }
+    catch (err) {
+        throw new Error('Failed to parse semver of engines.vscode');
+    }
+    try {
+        const typeSemver = (0, parse_semver_1.default)(`@types/vscode@${typeVersion}`);
+        plainTypeVersion = typeSemver.version;
+    }
+    catch (err) {
+        throw new Error('Failed to parse semver of @types/vscode');
+    }
+    // For all `x`, use smallest version for comparison
+    plainEngineVersion = plainEngineVersion.replace(/x/g, '0');
+    const [typeMajor, typeMinor] = plainTypeVersion.split('.').map(x => {
+        try {
+            return parseInt(x);
+        }
+        catch (err) {
+            return 0;
+        }
+    });
+    const [engineMajor, engineMinor] = plainEngineVersion.split('.').map(x => {
+        try {
+            return parseInt(x);
+        }
+        catch (err) {
+            return 0;
+        }
+    });
+    const error = new Error(`@types/vscode ${typeVersion} greater than engines.vscode ${engineVersion}. Consider upgrade engines.vscode or use an older @types/vscode version`);
+    if (typeMajor > engineMajor) {
+        throw error;
+    }
+    if (typeMajor === engineMajor && typeMinor > engineMinor) {
+        throw error;
+    }
+}
+exports.validateVSCodeTypesCompatibility = validateVSCodeTypesCompatibility;
+//# sourceMappingURL=validation.js.map

package/out/viewutils.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wordTrim = exports.indentRow = exports.wordWrap = exports.tableView = exports.ratingStars = exports.repeatString = exports.formatDateTime = exports.formatTime = exports.formatDate = exports.icons = void 0;
+const fixedLocale = 'en-us';
+const format = {
+    date: { month: 'long', day: 'numeric', year: 'numeric' },
+    time: { hour: 'numeric', minute: 'numeric', second: 'numeric' },
+};
+const columns = process.stdout.columns ? process.stdout.columns : 80;
+// xxx: Windows cmd + powershell standard fonts currently don't support the full
+// unicode charset. For now we use fallback icons when on windows.
+const useFallbackIcons = process.platform === 'win32';
+exports.icons = useFallbackIcons
+    ? { download: '\u{2193}', star: '\u{2665}', emptyStar: '\u{2022}' }
+    : { download: '\u{2913}', star: '\u{2605}', emptyStar: '\u{2606}' };
+function formatDate(date) {
+    return date.toLocaleString(fixedLocale, format.date);
+}
+exports.formatDate = formatDate;
+function formatTime(date) {
+    return date.toLocaleString(fixedLocale, format.time);
+}
+exports.formatTime = formatTime;
+function formatDateTime(date) {
+    return date.toLocaleString(fixedLocale, { ...format.date, ...format.time });
+}
+exports.formatDateTime = formatDateTime;
+function repeatString(text, count) {
+    let result = '';
+    for (let i = 0; i < count; i++) {
+        result += text;
+    }
+    return result;
+}
+exports.repeatString = repeatString;
+function ratingStars(rating, total = 5) {
+    const c = Math.min(Math.round(rating), total);
+    return `${repeatString(exports.icons.star + ' ', c)}${repeatString(exports.icons.emptyStar + ' ', total - c)}`;
+}
+exports.ratingStars = ratingStars;
+function tableView(table, spacing = 2) {
+    const maxLen = {};
+    table.forEach(row => row.forEach((cell, i) => (maxLen[i] = Math.max(maxLen[i] || 0, cell.length))));
+    return table.map(row => row.map((cell, i) => `${cell}${repeatString(' ', maxLen[i] - cell.length + spacing)}`).join(''));
+}
+exports.tableView = tableView;
+function wordWrap(text, width = columns) {
+    const [indent = ''] = text.match(/^\s+/) || [];
+    const maxWidth = width - indent.length;
+    return text
+        .replace(/^\s+/, '')
+        .split('')
+        .reduce(([out, buffer, pos], ch) => {
+        const nl = pos === maxWidth ? `\n${indent}` : '';
+        const newPos = nl ? 0 : +pos + 1;
+        return / |-|,|\./.test(ch) ? [`${out}${buffer}${ch}${nl}`, '', newPos] : [`${out}${nl}`, buffer + ch, newPos];
+    }, [indent, '', 0])
+        .slice(0, 2)
+        .join('');
+}
+exports.wordWrap = wordWrap;
+function indentRow(row) {
+    return `  ${row}`;
+}
+exports.indentRow = indentRow;
+function wordTrim(text, width = columns, indicator = '...') {
+    if (text.length > width) {
+        return text.substr(0, width - indicator.length) + indicator;
+    }
+    return text;
+}
+exports.wordTrim = wordTrim;
+//# sourceMappingURL=viewutils.js.map

package/out/xml.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseContentTypes = exports.parseXmlManifest = void 0;
+const util_1 = require("util");
+const xml2js_1 = require("xml2js");
+function createXMLParser() {
+    return (0, util_1.promisify)(xml2js_1.parseString);
+}
+exports.parseXmlManifest = createXMLParser();
+exports.parseContentTypes = createXMLParser();
+//# sourceMappingURL=xml.js.map

package/out/zip.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readVSIXPackage = exports.readZip = void 0;
+const yauzl_1 = require("yauzl");
+const xml_1 = require("./xml");
+async function bufferStream(stream) {
+    return await new Promise((c, e) => {
+        const buffers = [];
+        stream.on('data', buffer => buffers.push(buffer));
+        stream.once('error', e);
+        stream.once('end', () => c(Buffer.concat(buffers)));
+    });
+}
+async function readZip(packagePath, filter) {
+    const zipfile = await new Promise((c, e) => (0, yauzl_1.open)(packagePath, { lazyEntries: true }, (err, zipfile) => (err ? e(err) : c(zipfile))));
+    return await new Promise((c, e) => {
+        const result = new Map();
+        zipfile.once('close', () => c(result));
+        zipfile.readEntry();
+        zipfile.on('entry', (entry) => {
+            const name = entry.fileName.toLowerCase();
+            if (filter(name)) {
+                zipfile.openReadStream(entry, (err, stream) => {
+                    if (err) {
+                        zipfile.close();
+                        return e(err);
+                    }
+                    bufferStream(stream).then(buffer => {
+                        result.set(name, buffer);
+                        zipfile.readEntry();
+                    });
+                });
+            }
+            else {
+                zipfile.readEntry();
+            }
+        });
+    });
+}
+exports.readZip = readZip;
+async function readVSIXPackage(packagePath) {
+    const map = await readZip(packagePath, name => /^extension\/package\.json$|^extension\.vsixmanifest$/i.test(name));
+    const rawManifest = map.get('extension/package.json');
+    if (!rawManifest) {
+        throw new Error('Manifest not found');
+    }
+    const rawXmlManifest = map.get('extension.vsixmanifest');
+    if (!rawXmlManifest) {
+        throw new Error('VSIX manifest not found');
+    }
+    return {
+        manifest: JSON.parse(rawManifest.toString('utf8')),
+        xmlManifest: await (0, xml_1.parseXmlManifest)(rawXmlManifest.toString('utf8')),
+    };
+}
+exports.readVSIXPackage = readVSIXPackage;
+//# sourceMappingURL=zip.js.map

package/package.json

@@ -0,0 +1,99 @@
+{
+	"name": "@vscode/vsce",
+	"version": "2.15.0",
+	"description": "VSCode Extension Manager",
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/Microsoft/vsce"
+	},
+	"homepage": "https://code.visualstudio.com",
+	"bugs": "https://github.com/Microsoft/vsce/issues",
+	"keywords": [
+		"vscode",
+		"vsce",
+		"extension"
+	],
+	"publishConfig": {
+		"access": "public"
+	},
+	"contributors": [
+		"Microsoft Corporation"
+	],
+	"author": "Microsoft Corporation",
+	"license": "MIT",
+	"main": "out/api.js",
+	"typings": "out/api.d.ts",
+	"bin": {
+		"vsce": "vsce"
+	},
+	"scripts": {
+		"compile": "tsc",
+		"build": "tsc",
+		"watch:build": "npm run compile -- --watch",
+		"test": "mocha",
+		"watch:test": "npm run test -- --watch",
+		"prepare": "husky install"
+	},
+	"engines": {
+		"node": ">= 14"
+	},
+	"dependencies": {
+		"azure-devops-node-api": "^11.0.1",
+		"chalk": "^2.4.2",
+		"cheerio": "^1.0.0-rc.9",
+		"commander": "^6.1.0",
+		"glob": "^7.0.6",
+		"hosted-git-info": "^4.0.2",
+		"keytar": "^7.7.0",
+		"leven": "^3.1.0",
+		"markdown-it": "^12.3.2",
+		"mime": "^1.3.4",
+		"minimatch": "^3.0.3",
+		"parse-semver": "^1.1.1",
+		"read": "^1.0.7",
+		"semver": "^5.1.0",
+		"tmp": "^0.2.1",
+		"typed-rest-client": "^1.8.4",
+		"url-join": "^4.0.1",
+		"xml2js": "^0.4.23",
+		"yauzl": "^2.3.1",
+		"yazl": "^2.2.2"
+	},
+	"devDependencies": {
+		"@types/cheerio": "^0.22.29",
+		"@types/glob": "^7.1.1",
+		"@types/hosted-git-info": "^3.0.2",
+		"@types/markdown-it": "^0.0.2",
+		"@types/mime": "^1",
+		"@types/minimatch": "^3.0.3",
+		"@types/mocha": "^7.0.2",
+		"@types/node": "^14.17.32",
+		"@types/read": "^0.0.28",
+		"@types/semver": "^6.0.0",
+		"@types/tmp": "^0.2.2",
+		"@types/url-join": "^4.0.1",
+		"@types/xml2js": "^0.4.4",
+		"@types/yauzl": "^2.9.2",
+		"@types/yazl": "^2.4.2",
+		"husky": "^7.0.4",
+		"mocha": "^9.2.0",
+		"prettier": "2.1.2",
+		"pretty-quick": "^3.0.2",
+		"source-map-support": "^0.4.2",
+		"ts-node": "^10.0.0",
+		"typescript": "^4.3.2"
+	},
+	"mocha": {
+		"require": [
+			"ts-node/register"
+		],
+		"watch-files": "src/**",
+		"spec": "src/test/**/*.ts"
+	},
+	"prettier": {
+		"useTabs": true,
+		"printWidth": 120,
+		"singleQuote": true,
+		"arrowParens": "avoid"
+	}
+}

package/vsce

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+require('./out/main')(process.argv);