azure-devops-extension-api 4.270.0 → 5.271.0

package/esm/Common/Util/Url.js

@@ -0,0 +1,595 @@
+/*
+ * ---------------------------------------------------------
+ * Copyright(C) Microsoft Corporation. All rights reserved.
+ * ---------------------------------------------------------
+ */
+/**
+ * Key constants used by route parsing.
+ */
+var KeyCodes;
+(function (KeyCodes) {
+    KeyCodes[KeyCodes["asterisk"] = 42] = "asterisk";
+    KeyCodes[KeyCodes["endCurlyBrace"] = 125] = "endCurlyBrace";
+    KeyCodes[KeyCodes["startCurlyBrace"] = 123] = "startCurlyBrace";
+})(KeyCodes || (KeyCodes = {}));
+function prepareForComparison(value, upperCase) {
+    return value ? (upperCase ? value.toLocaleUpperCase() : value) : "";
+}
+function stringEquals(str1, str2, ignoreCase) {
+    if (str1 === str2) {
+        return true;
+    }
+    return prepareForComparison(str1, ignoreCase).localeCompare(prepareForComparison(str2, ignoreCase)) === 0;
+}
+/**
+* Class that represents a Uri and allows parsing/getting and setting of individual parts
+*/
+export class Uri {
+    /**
+    * Create a new Uri.
+    *
+    * @param uri Optional uri string to populate values with
+    * @param options Options for parsing the uri string
+    */
+    constructor(uri, options) {
+        /**
+        * The uri scheme such as http or https
+        */
+        this.scheme = "";
+        /**
+         * If true, do not emit the "//" separator after the scheme:
+         * Set to true for schemes like mailto (e.g. mailto:foo@bar)
+         */
+        this.noSchemeSeparator = false;
+        /**
+        * The uri hostname (does not include port or scheme)
+        */
+        this.host = "";
+        /**
+        * The port number of the uri as supplied in the url. 0 if left out in the url (e.g. the default port for the scheme).
+        */
+        this.port = 0;
+        /**
+        * The relative path of the uri
+        */
+        this.path = "";
+        /**
+        * The array of query parameters in the uri
+        */
+        this.queryParameters = [];
+        /**
+        * The hash string of the uri
+        */
+        this.hashString = "";
+        if (uri) {
+            this._setFromUriString(uri, options);
+        }
+    }
+    _setFromUriString(uriString, options) {
+        let uri = uriString;
+        // Parse out the hash string
+        let hashSplit = this._singleSplit(uri, "#");
+        if (hashSplit) {
+            uri = hashSplit.part1;
+            this.hashString = this._decodeUriComponent(hashSplit.part2);
+        }
+        else {
+            this.hashString = "";
+        }
+        // Parse the query parameters
+        let querySplit = this._singleSplit(uri, "?");
+        if (querySplit) {
+            uri = querySplit.part1;
+            this.queryString = querySplit.part2;
+        }
+        else {
+            this.queryParameters = [];
+        }
+        this.scheme = "";
+        this.host = "";
+        this.port = 0;
+        this.path = "";
+        // Parse out the scheme components of the uri
+        this.noSchemeSeparator = false;
+        const schemeSplit = this._singleSplit(uri, ":");
+        if (schemeSplit) {
+            this.scheme = schemeSplit.part1;
+            uri = schemeSplit.part2;
+            if (uri.substr(0, 2) === "//") {
+                uri = uri.substr(2);
+                // Parse out the path part of the uri
+                const pathSplit = this._singleSplit(uri, "/");
+                if (pathSplit) {
+                    uri = pathSplit.part1;
+                    this.path = pathSplit.part2;
+                }
+                else {
+                    this.path = "";
+                }
+                // Parse out the port number
+                const portSplit = this._singleSplit(uri, ":");
+                if (portSplit) {
+                    this.host = portSplit.part1;
+                    this.port = parseInt(portSplit.part2);
+                    if (isNaN(this.port)) {
+                        // Segment after : was not a port, consider it part of the path
+                        this.host += ":";
+                        this.path = portSplit.part2 + "/" + this.path;
+                    }
+                }
+                else {
+                    this.host = uri;
+                }
+            }
+            else {
+                // No host for schemes like mailto: just use path
+                this.noSchemeSeparator = true;
+                this.path = uri;
+            }
+        }
+        else {
+            // Relative Url was given
+            this.path = uri;
+        }
+        if (options && options.absoluteUriRequired && !this.scheme) {
+            throw new Error(`The uri string "${uriString}" does not represent a valid absolute uri.`);
+        }
+    }
+    _singleSplit(value, separator) {
+        const matchIndex = value.indexOf(separator);
+        if (matchIndex >= 0) {
+            return {
+                part1: value.substr(0, matchIndex),
+                part2: value.substr(matchIndex + 1)
+            };
+        }
+        else {
+            return undefined;
+        }
+    }
+    _decodeUriComponent(value) {
+        if (value) {
+            // Replace "+" character with %20.
+            value = value.replace(/\+/g, "%20");
+            value = decodeURIComponent(value);
+        }
+        return value;
+    }
+    /**
+    * Get the absolute uri string for this Uri
+    */
+    get absoluteUri() {
+        let uri = "";
+        if (this.scheme) {
+            uri = encodeURI(decodeURI(this.scheme)) + ":";
+            if (!this.noSchemeSeparator) {
+                uri += "//";
+            }
+        }
+        if (this.host) {
+            uri += encodeURI(decodeURI(this.host));
+            if (this.port) {
+                uri += ":" + this.port;
+            }
+            if (!this.noSchemeSeparator || this.path) {
+                uri += "/";
+            }
+        }
+        if (this.path) {
+            let encodedPath;
+            if (this.noSchemeSeparator) {
+                // Only do simple encoding for schemes like mailto: or blob: where
+                // we can't determine host versus path
+                encodedPath = encodeURI(decodeURI(this.path));
+            }
+            else {
+                const parts = this.path.split('/');
+                encodedPath = parts.map(p => encodeURIComponent(decodeURIComponent(p))).join("/");
+            }
+            if (this.host) {
+                uri = combineUrlPaths(uri, encodedPath);
+            }
+            else {
+                uri = uri + encodedPath;
+            }
+        }
+        const queryString = this.queryString;
+        if (queryString) {
+            uri += "?" + queryString;
+        }
+        if (this.hashString) {
+            const params = this._splitStringIntoParams(this.hashString);
+            const encodedString = this._getParamsAsString(params);
+            uri += "#" + encodedString;
+        }
+        return uri;
+    }
+    /**
+    * Set the absolute uri string for this Uri. Replaces all existing values
+    */
+    set absoluteUri(uri) {
+        this._setFromUriString(uri || "");
+    }
+    /**
+     * Gets the effective port number, returning the default port number if omitted for the given scheme.
+     */
+    getEffectivePort() {
+        if (this.port) {
+            return this.port;
+        }
+        else {
+            if (stringEquals(this.scheme, "http", true)) {
+                return 80;
+            }
+            else if (stringEquals(this.scheme, "https", true)) {
+                return 443;
+            }
+            else {
+                return 0;
+            }
+        }
+    }
+    /**
+     * Builds an encoded key/value pair string
+     * like query string or hash strings
+     */
+    _getParamsAsString(params) {
+        if (params && params.length) {
+            return params.map((param) => {
+                if (param.value !== null) {
+                    return encodeURIComponent(param.name) + "=" + encodeURIComponent(param.value);
+                }
+                else {
+                    return encodeURIComponent(param.name);
+                }
+            }).join("&");
+        }
+        else {
+            return "";
+        }
+    }
+    /**
+    * Get the query string for this Uri.
+    */
+    get queryString() {
+        return this._getParamsAsString(this.queryParameters);
+    }
+    /**
+    * Set the query string for this Uri. Replaces existing value
+    */
+    set queryString(queryString) {
+        this.queryParameters = this._splitStringIntoParams(queryString);
+    }
+    /**
+     * Coverts a key/value pair string into parameters array
+     * @param paramString String such as a=b&c=d
+     */
+    _splitStringIntoParams(paramString) {
+        let params = [];
+        paramString.split('&').forEach((pair) => {
+            if (pair) {
+                const valueSplit = this._singleSplit(pair, "=");
+                if (valueSplit) {
+                    params.push({
+                        name: this._decodeUriComponent(valueSplit.part1),
+                        value: this._decodeUriComponent(valueSplit.part2)
+                    });
+                }
+                else {
+                    params.push({
+                        name: this._decodeUriComponent(pair),
+                        value: null
+                    });
+                }
+            }
+        });
+        return params;
+    }
+    /**
+    * Get the value of the query parameter with the given key
+    *
+    * @param name Query parameter name
+    */
+    getQueryParam(name) {
+        let value;
+        if (this.queryParameters) {
+            let matchingPairs = this.queryParameters.filter(p => stringEquals(p.name, name, true));
+            if (matchingPairs.length > 0) {
+                value = matchingPairs[0].value;
+            }
+        }
+        return value;
+    }
+    /**
+     * Adds a query string parameter to the current uri
+     *
+     * @param name The Query parameter name
+     * @param value The Query parameter value
+     * @param replaceExisting If true, replace all existing parameters with the same name
+     */
+    addQueryParam(name, value, replaceExisting) {
+        if (replaceExisting) {
+            this.removeQueryParam(name);
+        }
+        if (!this.queryParameters) {
+            this.queryParameters = [];
+        }
+        this.queryParameters.push({ name: name, value: value });
+    }
+    /**
+     * Adds query string parameters to the current uri
+     *
+     * @param parameters Query parameters to add
+     * @param replaceExisting If true, replace all existing parameters with the same name
+     * @param keyPrefix If specified, a value to prepend to all query parameter keys
+     */
+    addQueryParams(parameters, replaceExisting, keyPrefix) {
+        for (const key in parameters) {
+            const value = parameters[key];
+            if (value !== null && value !== undefined) {
+                const keyWithPrefix = (keyPrefix || "") + key;
+                if (value instanceof Date) {
+                    this.addQueryParam(keyWithPrefix, value.toJSON(), replaceExisting);
+                }
+                else if (Array.isArray(value)) {
+                    value.forEach(v => this.addQueryParam(keyWithPrefix, "" + v, replaceExisting));
+                }
+                else if (typeof value === "object") {
+                    this.addQueryParams(value, replaceExisting, keyWithPrefix + ".");
+                }
+                else {
+                    this.addQueryParam(keyWithPrefix, "" + value, replaceExisting);
+                }
+            }
+        }
+    }
+    /**
+     * Removes a query string parameter
+     *
+     * @param name The Query parameter name
+     */
+    removeQueryParam(name) {
+        if (this.queryParameters) {
+            this.queryParameters = this.queryParameters.filter(p => !stringEquals(p.name, name, true));
+        }
+    }
+}
+/**
+ * Take url segments and join them with a single slash character. Takes care of path segements that start and/or end
+ * with a slash to ensure that the resulting URL does not have double-slashes
+ *
+ * @param paths Path segments to concatenate
+ */
+export function combineUrlPaths(...paths) {
+    let segmentsToJoin = [];
+    // Trim leading and trailing slash in each segment
+    for (let i = 0, last = paths.length - 1; i <= last; i++) {
+        let path = paths[i];
+        if (path) {
+            if (path === "/" && (i === 0 || i === last)) {
+                // For a "/" segment at the beginning or end of the list, insert an empty entry to force
+                // a leading or trailing slash in the resulting URL
+                segmentsToJoin.push("");
+            }
+            else {
+                if (i > 0 && path[0] === "/") {
+                    // Trim leading slash in any segment except the first one
+                    path = path.substr(1);
+                }
+                if (i < last && path[path.length - 1] === "/") {
+                    // Trim trailing slash in any segment except the last one
+                    path = path.substr(0, path.length - 1);
+                }
+                if (path) {
+                    segmentsToJoin.push(path);
+                }
+            }
+        }
+    }
+    if (segmentsToJoin.length === 1 && segmentsToJoin[0] === "") {
+        return "/";
+    }
+    // Join segments by slash
+    return segmentsToJoin.join("/");
+}
+/**
+ * Parse a route template into a structure that can be used to quickly do route replacements
+ *
+ * @param routeTemplate MVC route template string (like "/foo/{id}/{*params}")
+ */
+export function parseRouteTemplate(routeTemplate) {
+    const parsedRoute = {
+        segments: []
+    };
+    let paramStartIndex = -1;
+    let segmentStartIndex = -1;
+    let segmentPrefix = "";
+    for (let charIndex = 0, routeTemplateLen = routeTemplate.length; charIndex < routeTemplateLen; charIndex++) {
+        let c = routeTemplate.charCodeAt(charIndex);
+        if (paramStartIndex >= 0) {
+            if (c === 125 /* KeyCodes.endCurlyBrace */) {
+                let paramName = routeTemplate.substring(paramStartIndex, charIndex);
+                let isWildCardParam = false;
+                if (paramName.charCodeAt(0) === 42 /* KeyCodes.asterisk */) {
+                    paramName = paramName.substr(1);
+                    isWildCardParam = true;
+                }
+                parsedRoute.segments.push({
+                    paramName,
+                    isWildCardParam
+                });
+                paramStartIndex = -1;
+            }
+        }
+        else {
+            if (c === 123 /* KeyCodes.startCurlyBrace */ && routeTemplate.charCodeAt(charIndex + 1) !== 123 /* KeyCodes.startCurlyBrace */) {
+                // Start of a parameter
+                if (segmentPrefix || segmentStartIndex >= 0) {
+                    // Store the previous segment
+                    let segmentText = segmentPrefix;
+                    if (segmentStartIndex >= 0) {
+                        segmentText += routeTemplate.substring(segmentStartIndex, charIndex);
+                    }
+                    if (segmentText) {
+                        parsedRoute.segments.push({
+                            text: segmentText
+                        });
+                    }
+                    // Reset the segment tracking info
+                    segmentStartIndex = -1;
+                    segmentPrefix = "";
+                }
+                paramStartIndex = charIndex + 1;
+            }
+            else {
+                // Handle double {{ or double }} as an escape sequence. This is rare. For simplicity we will 
+                if ((c === 123 /* KeyCodes.startCurlyBrace */ && routeTemplate.charCodeAt(charIndex + 1) === 123 /* KeyCodes.startCurlyBrace */) ||
+                    (c === 125 /* KeyCodes.endCurlyBrace */ && routeTemplate.charCodeAt(charIndex + 1) === 125 /* KeyCodes.endCurlyBrace */)) {
+                    segmentPrefix = segmentPrefix + routeTemplate.substring(segmentStartIndex >= 0 ? segmentStartIndex : charIndex, charIndex + 1);
+                    segmentStartIndex = -1;
+                    charIndex++;
+                }
+                if (segmentStartIndex < 0) {
+                    segmentStartIndex = charIndex;
+                }
+            }
+        }
+    }
+    // Store any pending segment
+    if (segmentStartIndex >= 0 || paramStartIndex >= 0) {
+        const segmentText = segmentPrefix + routeTemplate.substring(segmentStartIndex >= 0 ? segmentStartIndex : paramStartIndex);
+        if (segmentText) {
+            parsedRoute.segments.push({
+                text: segmentText
+            });
+        }
+    }
+    // Mark any param as required if it has a text segment (other than just "/") after it
+    let required = false;
+    for (let i = parsedRoute.segments.length - 1; i >= 0; i--) {
+        let segment = parsedRoute.segments[i];
+        if (segment.text && segment.text !== "/") {
+            required = true;
+        }
+        else if (required && segment.paramName) {
+            segment.isRequiredParam = true;
+        }
+    }
+    return parsedRoute;
+}
+/**
+ * Take a set of routes and route values and form a url using the best match. The best match
+ * is the route with the highest number of replacements (of the given routeValues dictionary).
+ * In the event of a tie (same number of replacements) the route that came first wins.
+ *
+ * @param routeCollection Array of parsed routes
+ * @param routeValues Replacement values
+ */
+export function routeUrl(routeCollection, routeValues) {
+    let bestMatch = getBestRouteMatch(routeCollection, routeValues);
+    if (!bestMatch) {
+        return "";
+    }
+    let uri = new Uri(bestMatch.url);
+    for (let routeValueKey in routeValues) {
+        if (!bestMatch.matchedParameters[routeValueKey]) {
+            uri.addQueryParam(routeValueKey, routeValues[routeValueKey]);
+        }
+    }
+    return uri.absoluteUri;
+}
+/**
+ * Take a set of routes and find the best match. The best match is the route with the highest number of replacements
+ * (of the given routeValues dictionary). In the event of a tie (same number of replacements) the route that came first wins.
+ *
+ * @param routeCollection Array of parsed routes
+ * @param routeValues Replacement values
+ */
+export function getBestRouteMatch(routeCollection, routeValues) {
+    let bestMatch;
+    let totalRouteValues = Object.keys(routeValues).length;
+    for (let route of routeCollection) {
+        let match = replaceParsedRouteValues(route, routeValues, false);
+        if (match && (!bestMatch || match.matchedParametersCount > bestMatch.matchedParametersCount)) {
+            bestMatch = match;
+            if (match.matchedParametersCount === totalRouteValues) {
+                // This route matched all route values. Return its url directly (no need to even add query params)
+                return bestMatch;
+            }
+        }
+    }
+    return bestMatch;
+}
+/**
+ * Replace route values for a specific parsed route
+ *
+ * @param parsedRoute The route to evaluate
+ * @param routeValues Dictionary of route replacement parameters
+ * @param continueOnUnmatchedSegements If true, continue with replacements even after a miss. By default (false), stop replacements once a parameter is not present.
+ */
+export function replaceParsedRouteValues(parsedRoute, routeValues, continueOnUnmatchedSegements) {
+    let urlParts = [];
+    let matchedParameters = {};
+    let matchedParametersCount = 0;
+    for (let segmentIndex = 0, l = parsedRoute.segments.length; segmentIndex < l; segmentIndex++) {
+        const segment = parsedRoute.segments[segmentIndex];
+        if (segment.text) {
+            let segmentText = segment.text;
+            if (continueOnUnmatchedSegements) {
+                // Make sure we don't have consecutive slash (/) characters in the case of missing segments
+                if (segmentIndex > 0 && segmentText.charAt(0) === "/") {
+                    if (urlParts.length === 0) {
+                        // First text segment after one or more missing parameter segments. Remove the leading slash.
+                        segmentText = segmentText.substr(1);
+                    }
+                }
+            }
+            if (segmentText) {
+                urlParts.push(segmentText);
+            }
+        }
+        else {
+            const value = routeValues[segment.paramName];
+            if (!value && value !== 0) {
+                // The route value was not supplied
+                if (!continueOnUnmatchedSegements) {
+                    if (segment.isRequiredParam) {
+                        // This is a required parameter. Return undefined since this route was not a match.
+                        return undefined;
+                    }
+                    else {
+                        // This is an omitted optional parameter. Return what we've computed so far.
+                        break;
+                    }
+                }
+                else if (urlParts.length) {
+                    // Unmatched segment being omitted. Remove any previously trailing slash
+                    let lastSegment = urlParts[urlParts.length - 1];
+                    if (lastSegment[lastSegment.length - 1] === "/") {
+                        urlParts[urlParts.length - 1] = lastSegment.substr(0, lastSegment.length - 1);
+                    }
+                }
+            }
+            else {
+                urlParts.push(segment.isWildCardParam ? encodeURI("" + value) : encodeURIComponent("" + value));
+                matchedParameters[segment.paramName] = true;
+                matchedParametersCount++;
+            }
+        }
+    }
+    return {
+        url: urlParts.join(""),
+        matchedParameters,
+        matchedParametersCount
+    };
+}
+/**
+ * Take an MVC route template (like "/foo/{id}/{*params}") and replace the templated parts with values from the given dictionary
+ *
+ * @param routeTemplate MVC route template (like "/foo/{id}/{*params}")
+ * @param routeValues Route value replacements
+ */
+export function replaceRouteValues(routeTemplate, routeValues) {
+    let parsedRoute = parseRouteTemplate(routeTemplate);
+    return replaceParsedRouteValues(parsedRoute, routeValues, true).url;
+}

package/esm/Common/Util/Url.min.js

@@ -0,0 +1 @@
+function prepareForComparison(t,e){return t?e?t.toLocaleUpperCase():t:""}function stringEquals(t,e,r){return t===e||0===prepareForComparison(t,r).localeCompare(prepareForComparison(e,r))}var KeyCodes;!function(t){t[t.asterisk=42]="asterisk",t[t.endCurlyBrace=125]="endCurlyBrace",t[t.startCurlyBrace=123]="startCurlyBrace"}(KeyCodes||(KeyCodes={}));export class Uri{constructor(t,e){this.scheme="",this.noSchemeSeparator=!1,this.host="",this.port=0,this.path="",this.queryParameters=[],this.hashString="",t&&this._setFromUriString(t,e)}_setFromUriString(t,e){let r=t,s=this._singleSplit(r,"#");s?(r=s.part1,this.hashString=this._decodeUriComponent(s.part2)):this.hashString="";let a=this._singleSplit(r,"?");a?(r=a.part1,this.queryString=a.part2):this.queryParameters=[],this.scheme="",this.host="",this.port=0,this.path="",this.noSchemeSeparator=!1;const i=this._singleSplit(r,":");if(i)if(this.scheme=i.part1,"//"===(r=i.part2).substr(0,2)){r=r.substr(2);const t=this._singleSplit(r,"/");t?(r=t.part1,this.path=t.part2):this.path="";const e=this._singleSplit(r,":");e?(this.host=e.part1,this.port=parseInt(e.part2),isNaN(this.port)&&(this.host+=":",this.path=e.part2+"/"+this.path)):this.host=r}else this.noSchemeSeparator=!0,this.path=r;else this.path=r;if(e&&e.absoluteUriRequired&&!this.scheme)throw new Error(`The uri string "${t}" does not represent a valid absolute uri.`)}_singleSplit(t,e){const r=t.indexOf(e);return r>=0?{part1:t.substr(0,r),part2:t.substr(r+1)}:void 0}_decodeUriComponent(t){return t&&(t=t.replace(/\+/g,"%20"),t=decodeURIComponent(t)),t}get absoluteUri(){let t="";if(this.scheme&&(t=encodeURI(decodeURI(this.scheme))+":",this.noSchemeSeparator||(t+="//")),this.host&&(t+=encodeURI(decodeURI(this.host)),this.port&&(t+=":"+this.port),this.noSchemeSeparator&&!this.path||(t+="/")),this.path){let e;if(this.noSchemeSeparator)e=encodeURI(decodeURI(this.path));else{e=this.path.split("/").map(t=>encodeURIComponent(decodeURIComponent(t))).join("/")}this.host?t=combineUrlPaths(t,e):t+=e}const e=this.queryString;if(e&&(t+="?"+e),this.hashString){const e=this._splitStringIntoParams(this.hashString);t+="#"+this._getParamsAsString(e)}return t}set absoluteUri(t){this._setFromUriString(t||"")}getEffectivePort(){return this.port?this.port:stringEquals(this.scheme,"http",!0)?80:stringEquals(this.scheme,"https",!0)?443:0}_getParamsAsString(t){return t&&t.length?t.map(t=>null!==t.value?encodeURIComponent(t.name)+"="+encodeURIComponent(t.value):encodeURIComponent(t.name)).join("&"):""}get queryString(){return this._getParamsAsString(this.queryParameters)}set queryString(t){this.queryParameters=this._splitStringIntoParams(t)}_splitStringIntoParams(t){let e=[];return t.split("&").forEach(t=>{if(t){const r=this._singleSplit(t,"=");r?e.push({name:this._decodeUriComponent(r.part1),value:this._decodeUriComponent(r.part2)}):e.push({name:this._decodeUriComponent(t),value:null})}}),e}getQueryParam(t){let e;if(this.queryParameters){let r=this.queryParameters.filter(e=>stringEquals(e.name,t,!0));r.length>0&&(e=r[0].value)}return e}addQueryParam(t,e,r){r&&this.removeQueryParam(t),this.queryParameters||(this.queryParameters=[]),this.queryParameters.push({name:t,value:e})}addQueryParams(t,e,r){for(const s in t){const a=t[s];if(null!==a&&void 0!==a){const t=(r||"")+s;a instanceof Date?this.addQueryParam(t,a.toJSON(),e):Array.isArray(a)?a.forEach(r=>this.addQueryParam(t,""+r,e)):"object"==typeof a?this.addQueryParams(a,e,t+"."):this.addQueryParam(t,""+a,e)}}}removeQueryParam(t){this.queryParameters&&(this.queryParameters=this.queryParameters.filter(e=>!stringEquals(e.name,t,!0)))}};export function combineUrlPaths(...t){let e=[];for(let r=0,s=t.length-1;r<=s;r++){let a=t[r];a&&("/"!==a||0!==r&&r!==s?(r>0&&"/"===a[0]&&(a=a.substr(1)),r<s&&"/"===a[a.length-1]&&(a=a.substr(0,a.length-1)),a&&e.push(a)):e.push(""))}return 1===e.length&&""===e[0]?"/":e.join("/")};export function parseRouteTemplate(t){const e={segments:[]};let r=-1,s=-1,a="";for(let i=0,n=t.length;i<n;i++){let n=t.charCodeAt(i);if(r>=0){if(125===n){let s=t.substring(r,i),a=!1;42===s.charCodeAt(0)&&(s=s.substr(1),a=!0),e.segments.push({paramName:s,isWildCardParam:a}),r=-1}}else if(123===n&&123!==t.charCodeAt(i+1)){if(a||s>=0){let r=a;s>=0&&(r+=t.substring(s,i)),r&&e.segments.push({text:r}),s=-1,a=""}r=i+1}else(123===n&&123===t.charCodeAt(i+1)||125===n&&125===t.charCodeAt(i+1))&&(a+=t.substring(s>=0?s:i,i+1),s=-1,i++),s<0&&(s=i)}if(s>=0||r>=0){const i=a+t.substring(s>=0?s:r);i&&e.segments.push({text:i})}let i=!1;for(let t=e.segments.length-1;t>=0;t--){let r=e.segments[t];r.text&&"/"!==r.text?i=!0:i&&r.paramName&&(r.isRequiredParam=!0)}return e};export function routeUrl(t,e){let r=getBestRouteMatch(t,e);if(!r)return"";let s=new Uri(r.url);for(let t in e)r.matchedParameters[t]||s.addQueryParam(t,e[t]);return s.absoluteUri};export function getBestRouteMatch(t,e){let r,s=Object.keys(e).length;for(let a of t){let t=replaceParsedRouteValues(a,e,!1);if(t&&(!r||t.matchedParametersCount>r.matchedParametersCount)&&(r=t,t.matchedParametersCount===s))return r}return r};export function replaceParsedRouteValues(t,e,r){let s=[],a={},i=0;for(let n=0,o=t.segments.length;n<o;n++){const o=t.segments[n];if(o.text){let t=o.text;r&&n>0&&"/"===t.charAt(0)&&0===s.length&&(t=t.substr(1)),t&&s.push(t)}else{const t=e[o.paramName];if(t||0===t)s.push(o.isWildCardParam?encodeURI(""+t):encodeURIComponent(""+t)),a[o.paramName]=!0,i++;else{if(!r){if(o.isRequiredParam)return;break}if(s.length){let t=s[s.length-1];"/"===t[t.length-1]&&(s[s.length-1]=t.substr(0,t.length-1))}}}}return{url:s.join(""),matchedParameters:a,matchedParametersCount:i}};export function replaceRouteValues(t,e){return replaceParsedRouteValues(parseRouteTemplate(t),e,!0).url};

package/esm/Common/index.js

@@ -0,0 +1,3 @@
+export * from "./Client";
+export * from "./CommonServices";
+export * from "./Context";

package/esm/Common/index.min.js

@@ -0,0 +1 @@
+export*from"./Client";export*from"./CommonServices";export*from"./Context";