genesys-cloud-service-discovery-web 3.0.57 → 3.0.60

package/index.js

@@ -8,34 +8,72 @@ function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'defau
 
 var parseUrl__default = /*#__PURE__*/_interopDefaultLegacy(parseUrl);
 
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+
+var __assign = function() {
+    __assign = Object.assign || function __assign(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+
+function __spreadArray(to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+}
+
 function assert(value, msg) {
     if (!value)
         throw new Error(msg);
 }
-function assertValidStringArray(value, valueName = 'value') {
-    assert(value instanceof Array, `${valueName} must be an array of strings`);
-    for (let name of value) {
-        assert(typeof name === "string", `Each item in ${valueName} must be a string`);
+function assertValidStringArray(value, valueName) {
+    if (valueName === void 0) { valueName = 'value'; }
+    assert(value instanceof Array, "".concat(valueName, " must be an array of strings"));
+    for (var _i = 0, value_1 = value; _i < value_1.length; _i++) {
+        var name_1 = value_1[_i];
+        assert(typeof name_1 === "string", "Each item in ".concat(valueName, " must be a string"));
     }
 }
 function parseValidUrl(value) {
     assert(typeof value === "string", "url is not a string");
     // Explicitly pass {} as 2nd param so that `url-parse` parses the url
     // independently from the browser's current window location
-    const url = parseUrl__default['default'](value, {});
-    assert(url.protocol && url.hostname, `invalid url: '${value}', unable to parse hostname`);
+    var url = parseUrl__default['default'](value, {});
+    assert(url.protocol && url.hostname, "invalid url: '".concat(value, "', unable to parse hostname"));
     return url;
 }
 function assertValidEnvFilters(value) {
     assert(!!value && typeof value === "object", "Provided filters must be an object");
-    const filters = value;
+    var filters = value;
     if (filters.env !== undefined) {
         assert(filters.env instanceof Array, 'filters.env must be an array');
-        assert(filters.env.every(env => ENVS.indexOf(env) >= 0), `'${filters.env}' - filters.env must be an array containing only: ${ENVS.join(',')}`);
+        assert(filters.env.every(function (env) { return ENVS.indexOf(env) >= 0; }), "'".concat(filters.env, "' - filters.env must be an array containing only: ").concat(ENVS.join(',')));
     }
     if (filters.status !== undefined) {
         assert(filters.status instanceof Array, 'filters.status must be an array');
-        assert(filters.status.every(status => STATUSES.indexOf(status) >= 0), `'${filters.status}' - filters.status must be an array containing only: ${STATUSES.join(',')}`);
+        assert(filters.status.every(function (status) { return STATUSES.indexOf(status) >= 0; }), "'".concat(filters.status, "' - filters.status must be an array containing only: ").concat(STATUSES.join(',')));
     }
 }
 
@@ -150,28 +188,29 @@ var _environments = [
 	}
 ];
 
-const environments = _environments;
-const ENVS = ["dev", "test", "prod", "fedramp"];
-const STATUSES = ["alpha", "beta", "stable", "archived"];
-const DEFAULT_LOCAL_HOSTNAMES = ["localhost", "127.0.0.1"];
-const STABLE_PUBLIC_ENVS_FILTERS = { env: ["prod", "fedramp"], status: ["stable"] };
-const NO_FILTERS = {};
-const endsWith = (s1, s2) => {
+var environments = _environments;
+var ENVS = ["dev", "test", "prod", "fedramp"];
+var STATUSES = ["alpha", "beta", "stable", "archived"];
+var DEFAULT_LOCAL_HOSTNAMES = ["localhost", "127.0.0.1"];
+var STABLE_PUBLIC_ENVS_FILTERS = { env: ["prod", "fedramp"], status: ["stable"] };
+var NO_FILTERS = {};
+var endsWith = function (s1, s2) {
     return s1.slice(s1.length - s2.length) === s2;
 };
-const matchesHostname = (hostname) => (domain) => {
-    return hostname === domain || endsWith(hostname, `.${domain}`);
-};
+var matchesHostname = function (hostname) { return function (domain) {
+    return hostname === domain || endsWith(hostname, ".".concat(domain));
+}; };
 /**
  * Retrieves the list of Genesys Cloud environment/region deployments.
  * Defaults to only returning stable, publically available deployments (e.g. prod, fedramp)
  */
-const getEnvironments = (filters = STABLE_PUBLIC_ENVS_FILTERS) => {
+var getEnvironments = function (filters) {
+    if (filters === void 0) { filters = STABLE_PUBLIC_ENVS_FILTERS; }
     assertValidEnvFilters(filters);
-    const { env, status } = filters;
+    var env = filters.env, status = filters.status;
     return environments
-        .filter(data => env === undefined || env.indexOf(data.env) >= 0)
-        .filter(data => status === undefined || status.indexOf(data.status) >= 0);
+        .filter(function (data) { return env === undefined || env.indexOf(data.env) >= 0; })
+        .filter(function (data) { return status === undefined || status.indexOf(data.status) >= 0; });
 };
 /**
  * Whether or not the given url is a known Genesys Cloud deployment.  If no filters
@@ -181,7 +220,7 @@ const getEnvironments = (filters = STABLE_PUBLIC_ENVS_FILTERS) => {
  * - throws an error if passed an invalid url
  * - returns false for localhost
  */
-const isKnown = (url, filters) => !!parse(url, filters);
+var isKnown = function (url, filters) { return !!parse(url, filters); };
 /**
  * Retrieve the Genesys Cloud `Environment` for a given url.  If no filters
  * are provided, the default behavior is to only check stable, publically available deployments
@@ -190,10 +229,11 @@ const isKnown = (url, filters) => !!parse(url, filters);
  * - throws an error if passed an invalid url
  * - returns undefined if no match is found
  */
-const parse = (url, filters) => {
-    const { hostname } = parseValidUrl(url);
-    return getEnvironments(filters).find(({ publicDomainName, publicDomainAliases }) => {
-        const domains = [publicDomainName, ...publicDomainAliases].filter(d => !!d);
+var parse = function (url, filters) {
+    var hostname = parseValidUrl(url).hostname;
+    return getEnvironments(filters).find(function (_a) {
+        var publicDomainName = _a.publicDomainName, publicDomainAliases = _a.publicDomainAliases;
+        var domains = __spreadArray([publicDomainName], publicDomainAliases, true).filter(function (d) { return !!d; });
         return domains.some(matchesHostname(hostname));
     });
 };
@@ -203,16 +243,17 @@ const parse = (url, filters) => {
  *
  * By default, this method will attempt to search across all available environments (no filtering).
  */
-const parseDeployedRuntime = (url = window.location.href, filters = NO_FILTERS) => {
+var parseDeployedRuntime = function (url, filters) {
+    if (url === void 0) { url = window.location.href; }
+    if (filters === void 0) { filters = NO_FILTERS; }
     assertValidEnvFilters(filters);
-    const { hostname } = parseValidUrl(url);
-    const parsedEnv = parse(url, filters);
+    var hostname = parseValidUrl(url).hostname;
+    var parsedEnv = parse(url, filters);
     if (!parsedEnv)
         return;
-    return Object.assign(Object.assign({}, parsedEnv), { local: false, currentDomainName: [
-            parsedEnv.publicDomainName,
-            ...parsedEnv.publicDomainAliases
-        ].filter(d => !!d).find(matchesHostname(hostname)) });
+    return __assign(__assign({}, parsedEnv), { local: false, currentDomainName: __spreadArray([
+            parsedEnv.publicDomainName
+        ], parsedEnv.publicDomainAliases, true).filter(function (d) { return !!d; }).find(matchesHostname(hostname)) });
 };
 /**
  * When the hostname matches a valid local hostname, either by matching our defaults or your custom list
@@ -225,17 +266,22 @@ const parseDeployedRuntime = (url = window.location.href, filters = NO_FILTERS)
  * Note: `currentDomainName` will be equal to `publicDomainName` when using this method.
  * Example: https://localhost:3000/prod => us-east-1 prod environment & runtime details
  */
-const parseRuntimeFromLocalPath = (localHostnames = DEFAULT_LOCAL_HOSTNAMES) => (url = window.location.href, filters = NO_FILTERS) => {
-    assertValidEnvFilters(filters);
-    assertValidStringArray(localHostnames, 'localHostnames');
-    const { hostname, pathname } = parseValidUrl(url);
-    if (localHostnames.indexOf(hostname) >= 0) {
-        const [, envName] = pathname.split("/");
-        const localEnv = getEnvironments(filters).find(e => e.name === envName);
-        if (!localEnv)
-            return;
-        return Object.assign(Object.assign({}, localEnv), { local: true, currentDomainName: localEnv.publicDomainName });
-    }
+var parseRuntimeFromLocalPath = function (localHostnames) {
+    if (localHostnames === void 0) { localHostnames = DEFAULT_LOCAL_HOSTNAMES; }
+    return function (url, filters) {
+        if (url === void 0) { url = window.location.href; }
+        if (filters === void 0) { filters = NO_FILTERS; }
+        assertValidEnvFilters(filters);
+        assertValidStringArray(localHostnames, 'localHostnames');
+        var _a = parseValidUrl(url), hostname = _a.hostname, pathname = _a.pathname;
+        if (localHostnames.indexOf(hostname) >= 0) {
+            var _b = pathname.split("/"), envName_1 = _b[1];
+            var localEnv = getEnvironments(filters).find(function (e) { return e.name === envName_1; });
+            if (!localEnv)
+                return;
+            return __assign(__assign({}, localEnv), { local: true, currentDomainName: localEnv.publicDomainName });
+        }
+    };
 };
 /**
  * This is the default and recommended `RuntimeParser` implementation that is composed of the
@@ -243,7 +289,9 @@ const parseRuntimeFromLocalPath = (localHostnames = DEFAULT_LOCAL_HOSTNAMES) =>
  * `parseDeployedRuntime` with your own `RuntimeParser` as an alternative to parseRuntimeFromLocalPath.
  * You may also opt to use "parse" and `getEnvironments` together to create your own parsing strategy.
  */
-const parseRuntime = (url = window.location.href, filters = NO_FILTERS) => {
+var parseRuntime = function (url, filters) {
+    if (url === void 0) { url = window.location.href; }
+    if (filters === void 0) { filters = NO_FILTERS; }
     return parseRuntimeFromLocalPath()(url, filters) || parseDeployedRuntime(url, filters);
 };