genesys-cloud-service-discovery-web 3.0.50 → 3.0.53

package/index.js

@@ -8,70 +8,34 @@ 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 __spreadArrays() {
-    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
-    for (var r = Array(s), k = 0, i = 0; i < il; i++)
-        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
-            r[k] = a[j];
-    return r;
-}
-
 function assert(value, msg) {
     if (!value)
         throw new Error(msg);
 }
-function assertValidStringArray(value, valueName) {
-    if (valueName === void 0) { valueName = 'value'; }
-    assert(value instanceof Array, 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 " + valueName + " must be a string");
+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 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
-    var url = parseUrl__default['default'](value, {});
-    assert(url.protocol && url.hostname, "invalid url: '" + value + "', unable to parse hostname");
+    const url = parseUrl__default['default'](value, {});
+    assert(url.protocol && url.hostname, `invalid url: '${value}', unable to parse hostname`);
     return url;
 }
 function assertValidEnvFilters(value) {
     assert(!!value && typeof value === "object", "Provided filters must be an object");
-    var filters = value;
+    const filters = value;
     if (filters.env !== undefined) {
         assert(filters.env instanceof Array, 'filters.env must be an array');
-        assert(filters.env.every(function (env) { return ENVS.indexOf(env) >= 0; }), "'" + filters.env + "' - filters.env must be an array containing only: " + ENVS.join(','));
+        assert(filters.env.every(env => ENVS.indexOf(env) >= 0), `'${filters.env}' - filters.env must be an array containing only: ${ENVS.join(',')}`);
     }
     if (filters.status !== undefined) {
         assert(filters.status instanceof Array, 'filters.status must be an array');
-        assert(filters.status.every(function (status) { return STATUSES.indexOf(status) >= 0; }), "'" + filters.status + "' - filters.status must be an array containing only: " + STATUSES.join(','));
+        assert(filters.status.every(status => STATUSES.indexOf(status) >= 0), `'${filters.status}' - filters.status must be an array containing only: ${STATUSES.join(',')}`);
     }
 }
 
@@ -166,6 +130,15 @@ var _environments = [
 		publicDomainAliases: [
 		]
 	},
+	{
+		name: "prod-sae1",
+		env: "prod",
+		region: "sa-east-1",
+		status: "beta",
+		publicDomainName: "sae1.pure.cloud",
+		publicDomainAliases: [
+		]
+	},
 	{
 		name: "prod-usw2",
 		env: "prod",
@@ -177,29 +150,28 @@ var _environments = [
 	}
 ];
 
-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) {
+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) => {
     return s1.slice(s1.length - s2.length) === s2;
 };
-var matchesHostname = function (hostname) { return function (domain) {
-    return hostname === domain || endsWith(hostname, "." + domain);
-}; };
+const matchesHostname = (hostname) => (domain) => {
+    return hostname === domain || endsWith(hostname, `.${domain}`);
+};
 /**
  * Retrieves the list of Genesys Cloud environment/region deployments.
  * Defaults to only returning stable, publically available deployments (e.g. prod, fedramp)
  */
-var getEnvironments = function (filters) {
-    if (filters === void 0) { filters = STABLE_PUBLIC_ENVS_FILTERS; }
+const getEnvironments = (filters = STABLE_PUBLIC_ENVS_FILTERS) => {
     assertValidEnvFilters(filters);
-    var env = filters.env, status = filters.status;
+    const { env, status } = filters;
     return environments
-        .filter(function (data) { return env === undefined || env.indexOf(data.env) >= 0; })
-        .filter(function (data) { return status === undefined || status.indexOf(data.status) >= 0; });
+        .filter(data => env === undefined || env.indexOf(data.env) >= 0)
+        .filter(data => status === undefined || status.indexOf(data.status) >= 0);
 };
 /**
  * Whether or not the given url is a known Genesys Cloud deployment.  If no filters
@@ -209,7 +181,7 @@ var getEnvironments = function (filters) {
  * - throws an error if passed an invalid url
  * - returns false for localhost
  */
-var isKnown = function (url, filters) { return !!parse(url, filters); };
+const isKnown = (url, filters) => !!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
@@ -218,11 +190,10 @@ var isKnown = function (url, filters) { return !!parse(url, filters); };
  * - throws an error if passed an invalid url
  * - returns undefined if no match is found
  */
-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 = __spreadArrays([publicDomainName], publicDomainAliases).filter(function (d) { return !!d; });
+const parse = (url, filters) => {
+    const { hostname } = parseValidUrl(url);
+    return getEnvironments(filters).find(({ publicDomainName, publicDomainAliases }) => {
+        const domains = [publicDomainName, ...publicDomainAliases].filter(d => !!d);
         return domains.some(matchesHostname(hostname));
     });
 };
@@ -232,17 +203,16 @@ var parse = function (url, filters) {
  *
  * By default, this method will attempt to search across all available environments (no filtering).
  */
-var parseDeployedRuntime = function (url, filters) {
-    if (url === void 0) { url = window.location.href; }
-    if (filters === void 0) { filters = NO_FILTERS; }
+const parseDeployedRuntime = (url = window.location.href, filters = NO_FILTERS) => {
     assertValidEnvFilters(filters);
-    var hostname = parseValidUrl(url).hostname;
-    var parsedEnv = parse(url, filters);
+    const { hostname } = parseValidUrl(url);
+    const parsedEnv = parse(url, filters);
     if (!parsedEnv)
         return;
-    return __assign(__assign({}, parsedEnv), { local: false, currentDomainName: __spreadArrays([
-            parsedEnv.publicDomainName
-        ], parsedEnv.publicDomainAliases).filter(function (d) { return !!d; }).find(matchesHostname(hostname)) });
+    return Object.assign(Object.assign({}, parsedEnv), { local: false, currentDomainName: [
+            parsedEnv.publicDomainName,
+            ...parsedEnv.publicDomainAliases
+        ].filter(d => !!d).find(matchesHostname(hostname)) });
 };
 /**
  * When the hostname matches a valid local hostname, either by matching our defaults or your custom list
@@ -255,22 +225,17 @@ var parseDeployedRuntime = function (url, filters) {
  * Note: `currentDomainName` will be equal to `publicDomainName` when using this method.
  * Example: https://localhost:3000/prod => us-east-1 prod environment & runtime details
  */
-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 });
-        }
-    };
+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 });
+    }
 };
 /**
  * This is the default and recommended `RuntimeParser` implementation that is composed of the
@@ -278,9 +243,7 @@ var parseRuntimeFromLocalPath = function (localHostnames) {
  * `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.
  */
-var parseRuntime = function (url, filters) {
-    if (url === void 0) { url = window.location.href; }
-    if (filters === void 0) { filters = NO_FILTERS; }
+const parseRuntime = (url = window.location.href, filters = NO_FILTERS) => {
     return parseRuntimeFromLocalPath()(url, filters) || parseDeployedRuntime(url, filters);
 };