@plusplusoneplusplus/coc 1.0.1 → 1.0.3

package/node_modules/azure-devops-node-api/VsoClient.d.ts

@@ -0,0 +1,53 @@
+import * as restm from 'typed-rest-client/RestClient';
+import ifm = require("./interfaces/common/VsoBaseInterfaces");
+export interface ClientVersioningData {
+    /**
+     * The api version string to send in the request (e.g. "1.0" or "2.0-preview.2")
+     */
+    apiVersion?: string;
+    /**
+     * The request path string to send the request to.  Looked up via an options request with the location id.
+     */
+    requestUrl?: string;
+}
+export declare class InvalidApiResourceVersionError implements Error {
+    name: string;
+    message: string;
+    constructor(message?: string);
+}
+/**
+ * Base class that should be used (derived from) to make requests to VSS REST apis
+ */
+export declare class VsoClient {
+    private static APIS_RELATIVE_PATH;
+    private static PREVIEW_INDICATOR;
+    private _locationsByAreaPromises;
+    private _initializationPromise;
+    restClient: restm.RestClient;
+    baseUrl: string;
+    basePath: string;
+    constructor(baseUrl: string, restClient: restm.RestClient);
+    protected autoNegotiateApiVersion(location: ifm.ApiResourceLocation, requestedVersion: string): string;
+    /**
+     * Gets the route template for a resource based on its location ID and negotiates the api version
+     */
+    getVersioningData(apiVersion: string, area: string, locationId: string, routeValues: any, queryParams?: any): Promise<ClientVersioningData>;
+    /**
+     * Sets a promise that is waited on before any requests are issued. Can be used to asynchronously
+     * set the request url and auth token manager.
+     */
+    _setInitializationPromise(promise: Promise<any>): void;
+    /**
+     * Gets information about an API resource location (route template, supported versions, etc.)
+     *
+     * @param area resource area name
+     * @param locationId Guid of the location to get
+     */
+    beginGetLocation(area: string, locationId: string): Promise<ifm.ApiResourceLocation | undefined>;
+    private beginGetAreaLocations;
+    resolveUrl(relativeUrl: string): string;
+    private queryParamsToStringHelper;
+    private queryParamsToString;
+    protected getRequestUrl(routeTemplate: string, area: string, resource: string, routeValues: any, queryParams?: any): string;
+    private replaceRouteValues;
+}

package/node_modules/azure-devops-node-api/VsoClient.js

@@ -0,0 +1,257 @@
+"use strict";
+//*******************************************************************************************************
+// significant portions of this file copied from: VSO\src\Vssf\WebPlatform\Platform\Scripts\VSS\WebApi\RestClient.ts
+//*******************************************************************************************************
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VsoClient = exports.InvalidApiResourceVersionError = void 0;
+/// Imports of 3rd Party ///
+const url = require("url");
+const path = require("path");
+class InvalidApiResourceVersionError {
+    constructor(message) {
+        this.name = "Invalid resource version";
+        this.message = message;
+    }
+}
+exports.InvalidApiResourceVersionError = InvalidApiResourceVersionError;
+/**
+ * Base class that should be used (derived from) to make requests to VSS REST apis
+ */
+class VsoClient {
+    constructor(baseUrl, restClient) {
+        this.baseUrl = baseUrl;
+        this.basePath = url.parse(baseUrl).pathname;
+        this.restClient = restClient;
+        this._locationsByAreaPromises = {};
+        this._initializationPromise = Promise.resolve(true);
+    }
+    autoNegotiateApiVersion(location, requestedVersion) {
+        let negotiatedVersion;
+        let apiVersion;
+        let apiVersionString;
+        if (requestedVersion) {
+            let apiVersionRegEx = new RegExp('(\\d+(\\.\\d+)?)(-preview(\\.(\\d+))?)?');
+            // Need to handle 3 types of api versions + invalid apiversion
+            // '2.1-preview.1' = ["2.1-preview.1", "2.1", ".1", -preview.1", ".1", "1"]
+            // '2.1-preview' = ["2.1-preview", "2.1", ".1", "-preview", undefined, undefined]
+            // '2.1' = ["2.1", "2.1", ".1", undefined, undefined, undefined]
+            let isPreview = false;
+            let resourceVersion;
+            let regExExecArray = apiVersionRegEx.exec(requestedVersion);
+            if (regExExecArray) {
+                if (regExExecArray[1]) {
+                    // we have an api version
+                    apiVersion = +regExExecArray[1];
+                    apiVersionString = regExExecArray[1];
+                    if (regExExecArray[3]) {
+                        // requesting preview
+                        isPreview = true;
+                        if (regExExecArray[5]) {
+                            // we have a resource version
+                            resourceVersion = +regExExecArray[5];
+                        }
+                    }
+                    // compare the location version and requestedversion
+                    if (apiVersion <= +location.releasedVersion
+                        || (!resourceVersion && apiVersion <= +location.maxVersion && isPreview)
+                        || (resourceVersion && apiVersion <= +location.maxVersion && resourceVersion <= +location.resourceVersion)) {
+                        negotiatedVersion = requestedVersion;
+                    }
+                    // else fall back to latest version of the resource from location
+                }
+            }
+        }
+        if (!negotiatedVersion) {
+            // Use the latest version of the resource if the api version was not specified in the request or if the requested version is higher then the location's supported version
+            if (apiVersion < +location.maxVersion) {
+                negotiatedVersion = apiVersionString + "-preview";
+            }
+            else if (location.maxVersion === location.releasedVersion) {
+                negotiatedVersion = location.maxVersion;
+            }
+            else {
+                negotiatedVersion = location.maxVersion + "-preview." + location.resourceVersion;
+            }
+        }
+        return negotiatedVersion;
+    }
+    /**
+     * Gets the route template for a resource based on its location ID and negotiates the api version
+     */
+    getVersioningData(apiVersion, area, locationId, routeValues, queryParams) {
+        let requestUrl;
+        return this.beginGetLocation(area, locationId)
+            .then((location) => {
+            if (!location) {
+                throw new Error("Failed to find api location for area: " + area + " id: " + locationId);
+            }
+            apiVersion = this.autoNegotiateApiVersion(location, apiVersion);
+            requestUrl = this.getRequestUrl(location.routeTemplate, location.area, location.resourceName, routeValues, queryParams);
+            return {
+                apiVersion: apiVersion,
+                requestUrl: requestUrl
+            };
+        });
+    }
+    /**
+     * Sets a promise that is waited on before any requests are issued. Can be used to asynchronously
+     * set the request url and auth token manager.
+     */
+    _setInitializationPromise(promise) {
+        if (promise) {
+            this._initializationPromise = promise;
+        }
+    }
+    /**
+     * Gets information about an API resource location (route template, supported versions, etc.)
+     *
+     * @param area resource area name
+     * @param locationId Guid of the location to get
+     */
+    beginGetLocation(area, locationId) {
+        return this._initializationPromise.then(() => {
+            return this.beginGetAreaLocations(area);
+        }).then((areaLocations) => {
+            return areaLocations[(locationId || "").toLowerCase()];
+        });
+    }
+    beginGetAreaLocations(area) {
+        let areaLocationsPromise = this._locationsByAreaPromises[area];
+        if (!areaLocationsPromise) {
+            let requestUrl = this.resolveUrl(VsoClient.APIS_RELATIVE_PATH + "/" + area);
+            areaLocationsPromise = this.restClient.options(requestUrl)
+                .then((res) => {
+                if (!res.result) {
+                    return {};
+                }
+                let locationsLookup = {};
+                let resourceLocations = res.result.value;
+                let i;
+                for (i = 0; i < resourceLocations.length; i++) {
+                    let resourceLocation = resourceLocations[i];
+                    locationsLookup[resourceLocation.id.toLowerCase()] = resourceLocation;
+                }
+                // If we have completed successfully, cache the response.
+                this._locationsByAreaPromises[area] = areaLocationsPromise;
+                return locationsLookup;
+            });
+        }
+        return areaLocationsPromise;
+    }
+    resolveUrl(relativeUrl) {
+        return url.resolve(this.baseUrl, path.join(this.basePath, relativeUrl));
+    }
+    queryParamsToStringHelper(queryParams, prefix) {
+        if (queryParams == null || queryParams.length === 0) {
+            return '';
+        }
+        let queryString = '';
+        if (typeof (queryParams) !== 'string') {
+            for (let property in queryParams) {
+                if (queryParams.hasOwnProperty(property)) {
+                    const prop = queryParams[property];
+                    const newPrefix = prefix + encodeURIComponent(property.toString()) + '.';
+                    queryString += this.queryParamsToStringHelper(prop, newPrefix);
+                }
+            }
+        }
+        if (queryString === '' && prefix.length > 0) {
+            // Date.prototype.toString() returns a string that is not valid for the REST API.
+            // Need to specially call `toUTCString()` instead for such cases
+            const queryValue = typeof queryParams === 'object' && 'toUTCString' in queryParams ? queryParams.toUTCString() : queryParams.toString();
+            // Will always need to chop period off of end of prefix
+            queryString = prefix.slice(0, -1) + '=' + encodeURIComponent(queryValue) + '&';
+        }
+        return queryString;
+    }
+    queryParamsToString(queryParams) {
+        const queryString = '?' + this.queryParamsToStringHelper(queryParams, '');
+        // Will always need to slice either a ? or & off of the end
+        return queryString.slice(0, -1);
+    }
+    getRequestUrl(routeTemplate, area, resource, routeValues, queryParams) {
+        // Add area/resource route values (based on the location)
+        routeValues = routeValues || {};
+        if (!routeValues.area) {
+            routeValues.area = area;
+        }
+        if (!routeValues.resource) {
+            routeValues.resource = resource;
+        }
+        // Replace templated route values
+        let relativeUrl = this.replaceRouteValues(routeTemplate, routeValues);
+        // Append query parameters to the end
+        if (queryParams) {
+            relativeUrl += this.queryParamsToString(queryParams);
+        }
+        // Resolve the relative url with the base
+        return url.resolve(this.baseUrl, path.join(this.basePath, relativeUrl));
+    }
+    // helper method copied directly from VSS\WebAPI\restclient.ts
+    replaceRouteValues(routeTemplate, routeValues) {
+        let result = "", currentPathPart = "", paramName = "", insideParam = false, charIndex, routeTemplateLength = routeTemplate.length, c;
+        for (charIndex = 0; charIndex < routeTemplateLength; charIndex++) {
+            c = routeTemplate[charIndex];
+            if (insideParam) {
+                if (c == "}") {
+                    insideParam = false;
+                    if (routeValues[paramName]) {
+                        currentPathPart += encodeURIComponent(routeValues[paramName]);
+                    }
+                    else {
+                        // Normalize param name in order to capture wild-card routes
+                        let strippedParamName = paramName.replace(/[^a-z0-9]/ig, '');
+                        if (routeValues[strippedParamName]) {
+                            currentPathPart += encodeURIComponent(routeValues[strippedParamName]);
+                        }
+                    }
+                    paramName = "";
+                }
+                else {
+                    paramName += c;
+                }
+            }
+            else {
+                if (c == "/") {
+                    if (currentPathPart) {
+                        if (result) {
+                            result += "/";
+                        }
+                        result += currentPathPart;
+                        currentPathPart = "";
+                    }
+                }
+                else if (c == "{") {
+                    if ((charIndex + 1) < routeTemplateLength && routeTemplate[charIndex + 1] == "{") {
+                        // Escaped '{'
+                        currentPathPart += c;
+                        charIndex++;
+                    }
+                    else {
+                        insideParam = true;
+                    }
+                }
+                else if (c == '}') {
+                    currentPathPart += c;
+                    if ((charIndex + 1) < routeTemplateLength && routeTemplate[charIndex + 1] == "}") {
+                        // Escaped '}'
+                        charIndex++;
+                    }
+                }
+                else {
+                    currentPathPart += c;
+                }
+            }
+        }
+        if (currentPathPart) {
+            if (result) {
+                result += "/";
+            }
+            result += currentPathPart;
+        }
+        return result;
+    }
+}
+exports.VsoClient = VsoClient;
+VsoClient.APIS_RELATIVE_PATH = "_apis";
+VsoClient.PREVIEW_INDICATOR = "-preview.";

package/node_modules/azure-devops-node-api/WebApi.d.ts

@@ -0,0 +1,104 @@
+import VsoBaseInterfaces = require('./interfaces/common/VsoBaseInterfaces');
+import alertm = require('./AlertApi');
+import buildm = require('./BuildApi');
+import corem = require('./CoreApi');
+import dashboardm = require('./DashboardApi');
+import extmgmtm = require("./ExtensionManagementApi");
+import featuremgmtm = require("./FeatureManagementApi");
+import filecontainerm = require('./FileContainerApi');
+import gallerym = require('./GalleryApi');
+import gitm = require('./GitApi');
+import locationsm = require('./LocationsApi');
+import managementm = require('./ManagementApi');
+import notificationm = require('./NotificationApi');
+import policym = require('./PolicyApi');
+import profilem = require('./ProfileApi');
+import projectm = require('./ProjectAnalysisApi');
+import releasem = require('./ReleaseApi');
+import securityrolesm = require('./SecurityRolesApi');
+import taskagentm = require('./TaskAgentApi');
+import taskm = require('./TaskApi');
+import testm = require('./TestApi');
+import testplanm = require('./TestPlanApi');
+import testresultsm = require('./TestResultsApi');
+import tfvcm = require('./TfvcApi');
+import wikim = require('./WikiApi');
+import workm = require('./WorkApi');
+import pipelinesm = require('./PipelinesApi');
+import cixm = require('./CIXApi');
+import workitemtrackingm = require('./WorkItemTrackingApi');
+import workitemtrackingprocessm = require('./WorkItemTrackingProcessApi');
+import workitemtrackingprocessdefinitionm = require('./WorkItemTrackingProcessDefinitionsApi');
+import * as rm from 'typed-rest-client/RestClient';
+import vsom = require('./VsoClient');
+import lim = require("./interfaces/LocationsInterfaces");
+/**
+ * Methods to return handler objects (see handlers folder)
+ */
+export declare function getBasicHandler(username: string, password: string, allowCrossOriginAuthentication?: boolean): VsoBaseInterfaces.IRequestHandler;
+export declare function getNtlmHandler(username: string, password: string, workstation?: string, domain?: string): VsoBaseInterfaces.IRequestHandler;
+export declare function getBearerHandler(token: string, allowCrossOriginAuthentication?: boolean): VsoBaseInterfaces.IRequestHandler;
+export declare function getPersonalAccessTokenHandler(token: string, allowCrossOriginAuthentication?: boolean): VsoBaseInterfaces.IRequestHandler;
+export declare function getHandlerFromToken(token: string, allowCrossOriginAuthentication?: boolean): VsoBaseInterfaces.IRequestHandler;
+export interface IWebApiRequestSettings {
+    productName: string;
+    productVersion: string;
+}
+export declare class WebApi {
+    serverUrl: string;
+    authHandler: VsoBaseInterfaces.IRequestHandler;
+    rest: rm.RestClient;
+    vsoClient: vsom.VsoClient;
+    options: VsoBaseInterfaces.IRequestOptions;
+    private _resourceAreas;
+    constructor(defaultUrl: string, authHandler: VsoBaseInterfaces.IRequestHandler, options?: VsoBaseInterfaces.IRequestOptions, requestSettings?: IWebApiRequestSettings);
+    /**
+     *  Convenience factory to create with a bearer token.
+     * @param defaultServerUrl default server url to use when creating new apis from factory methods
+     * @param defaultAuthHandler default authentication credentials to use when creating new apis from factory methods
+     */
+    static createWithBearerToken(defaultUrl: string, token: string, options?: VsoBaseInterfaces.IRequestOptions): WebApi;
+    connect(): Promise<lim.ConnectionData>;
+    /**
+     * Each factory method can take a serverUrl and a list of handlers
+     * if these aren't provided, the default url and auth handler given to the constructor for this class will be used
+     */
+    getAlertApi(serverUrl?: string, handlers?: VsoBaseInterfaces.IRequestHandler[]): Promise<alertm.IAlertApi>;
+    getBuildApi(serverUrl?: string, handlers?: VsoBaseInterfaces.IRequestHandler[]): Promise<buildm.IBuildApi>;
+    getCoreApi(serverUrl?: string, handlers?: VsoBaseInterfaces.IRequestHandler[]): Promise<corem.ICoreApi>;
+    getDashboardApi(serverUrl?: string, handlers?: VsoBaseInterfaces.IRequestHandler[]): Promise<dashboardm.IDashboardApi>;
+    getExtensionManagementApi(serverUrl?: string, handlers?: VsoBaseInterfaces.IRequestHandler[]): Promise<extmgmtm.IExtensionManagementApi>;
+    getFeatureManagementApi(serverUrl?: string, handlers?: VsoBaseInterfaces.IRequestHandler[]): Promise<featuremgmtm.IFeatureManagementApi>;
+    getFileContainerApi(serverUrl?: string, handlers?: VsoBaseInterfaces.IRequestHandler[]): Promise<filecontainerm.IFileContainerApi>;
+    getGalleryApi(serverUrl?: string, handlers?: VsoBaseInterfaces.IRequestHandler[]): Promise<gallerym.IGalleryApi>;
+    getGitApi(serverUrl?: string, handlers?: VsoBaseInterfaces.IRequestHandler[]): Promise<gitm.IGitApi>;
+    getLocationsApi(serverUrl?: string, handlers?: VsoBaseInterfaces.IRequestHandler[]): Promise<locationsm.ILocationsApi>;
+    getManagementApi(serverUrl?: string, handlers?: VsoBaseInterfaces.IRequestHandler[]): Promise<managementm.IManagementApi>;
+    getNotificationApi(serverUrl?: string, handlers?: VsoBaseInterfaces.IRequestHandler[]): Promise<notificationm.INotificationApi>;
+    getPolicyApi(serverUrl?: string, handlers?: VsoBaseInterfaces.IRequestHandler[]): Promise<policym.IPolicyApi>;
+    getProfileApi(serverUrl?: string, handlers?: VsoBaseInterfaces.IRequestHandler[]): Promise<profilem.IProfileApi>;
+    getProjectAnalysisApi(serverUrl?: string, handlers?: VsoBaseInterfaces.IRequestHandler[]): Promise<projectm.IProjectAnalysisApi>;
+    getSecurityRolesApi(serverUrl?: string, handlers?: VsoBaseInterfaces.IRequestHandler[]): Promise<securityrolesm.ISecurityRolesApi>;
+    getReleaseApi(serverUrl?: string, handlers?: VsoBaseInterfaces.IRequestHandler[]): Promise<releasem.IReleaseApi>;
+    getTaskApi(serverUrl?: string, handlers?: VsoBaseInterfaces.IRequestHandler[]): Promise<taskm.ITaskApi>;
+    getTaskAgentApi(serverUrl?: string, handlers?: VsoBaseInterfaces.IRequestHandler[]): Promise<taskagentm.ITaskAgentApi>;
+    getTestApi(serverUrl?: string, handlers?: VsoBaseInterfaces.IRequestHandler[]): Promise<testm.ITestApi>;
+    getTestPlanApi(serverUrl?: string, handlers?: VsoBaseInterfaces.IRequestHandler[]): Promise<testplanm.ITestPlanApi>;
+    getTestResultsApi(serverUrl?: string, handlers?: VsoBaseInterfaces.IRequestHandler[]): Promise<testresultsm.ITestResultsApi>;
+    getTfvcApi(serverUrl?: string, handlers?: VsoBaseInterfaces.IRequestHandler[]): Promise<tfvcm.ITfvcApi>;
+    getWikiApi(serverUrl?: string, handlers?: VsoBaseInterfaces.IRequestHandler[]): Promise<wikim.IWikiApi>;
+    getWorkApi(serverUrl?: string, handlers?: VsoBaseInterfaces.IRequestHandler[]): Promise<workm.IWorkApi>;
+    getWorkItemTrackingApi(serverUrl?: string, handlers?: VsoBaseInterfaces.IRequestHandler[]): Promise<workitemtrackingm.IWorkItemTrackingApi>;
+    getWorkItemTrackingProcessApi(serverUrl?: string, handlers?: VsoBaseInterfaces.IRequestHandler[]): Promise<workitemtrackingprocessm.IWorkItemTrackingProcessApi>;
+    getWorkItemTrackingProcessDefinitionApi(serverUrl?: string, handlers?: VsoBaseInterfaces.IRequestHandler[]): Promise<workitemtrackingprocessdefinitionm.IWorkItemTrackingProcessDefinitionsApi>;
+    getPipelinesApi(serverUrl?: string, handlers?: VsoBaseInterfaces.IRequestHandler[]): Promise<pipelinesm.IPipelinesApi>;
+    getCixApi(serverUrl?: string, handlers?: VsoBaseInterfaces.IRequestHandler[]): Promise<cixm.ICixApi>;
+    /**
+     * Determines if the domain is exluded for proxy via the no_proxy env var
+     * @param url: the server url
+     */
+    isNoProxyHost: (_url: string) => boolean;
+    private _getResourceAreaUrl;
+    private _getResourceAreas;
+    private _readTaskLibSecrets;
+}