@redhat-cloud-services/frontend-components-config-utilities 2.0.0-beta.1 → 2.0.0

package/repos/insights-chrome-build/js/vendors-node_modules_scalprum_core_dist_esm_index_js.b3f9836f62184986.js

@@ -0,0 +1,363 @@
+"use strict";
+(self["webpackChunkinsights_chrome"] = self["webpackChunkinsights_chrome"] || []).push([["vendors-node_modules_scalprum_core_dist_esm_index_js"],{
+
+/***/ "./node_modules/@scalprum/core/dist/esm/index.js":
+/*!*******************************************************!*\
+  !*** ./node_modules/@scalprum/core/dist/esm/index.js ***!
+  \*******************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "GLOBAL_NAMESPACE": () => (/* binding */ GLOBAL_NAMESPACE),
+/* harmony export */   "getAppData": () => (/* binding */ getAppData),
+/* harmony export */   "getCachedModule": () => (/* binding */ getCachedModule),
+/* harmony export */   "getPendingLoading": () => (/* binding */ getPendingLoading),
+/* harmony export */   "getPendingPrefetch": () => (/* binding */ getPendingPrefetch),
+/* harmony export */   "getScalprum": () => (/* binding */ getScalprum),
+/* harmony export */   "getSharedScope": () => (/* binding */ getSharedScope),
+/* harmony export */   "handlePrefetchPromise": () => (/* binding */ handlePrefetchPromise),
+/* harmony export */   "initSharedScope": () => (/* binding */ initSharedScope),
+/* harmony export */   "initialize": () => (/* binding */ initialize),
+/* harmony export */   "preloadModule": () => (/* binding */ preloadModule),
+/* harmony export */   "processManifest": () => (/* binding */ processManifest),
+/* harmony export */   "removePrefetch": () => (/* binding */ removePrefetch),
+/* harmony export */   "removeScalprum": () => (/* binding */ removeScalprum),
+/* harmony export */   "resolvePendingInjection": () => (/* binding */ resolvePendingInjection),
+/* harmony export */   "setPendingLoading": () => (/* binding */ setPendingLoading),
+/* harmony export */   "setPendingPrefetch": () => (/* binding */ setPendingPrefetch)
+/* harmony export */ });
+/* harmony import */ var _openshift_dynamic_plugin_sdk__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @openshift/dynamic-plugin-sdk */ "webpack/sharing/consume/default/@openshift/dynamic-plugin-sdk/@openshift/dynamic-plugin-sdk");
+/* harmony import */ var _openshift_dynamic_plugin_sdk__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_openshift_dynamic_plugin_sdk__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony import */ var _warnDuplicatePkg__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./warnDuplicatePkg */ "./node_modules/@scalprum/core/dist/esm/warnDuplicatePkg.js");
+var __assign = (undefined && undefined.__assign) || function () {
+    __assign = Object.assign || function(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);
+};
+var __awaiter = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (undefined && undefined.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+
+
+var GLOBAL_NAMESPACE = '__scalprum__';
+var SHARED_SCOPE_NAME = 'default';
+var scalprum;
+var getModuleIdentifier = function (scope, module) { return scope + "#" + module; };
+var getScalprum = function () {
+    if (!scalprum) {
+        throw new Error('Scalprum was not initialized! Call the initialize function first.');
+    }
+    return scalprum;
+};
+var initSharedScope = function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+    return [2, __webpack_require__.I(SHARED_SCOPE_NAME)];
+}); }); };
+var getSharedScope = function (enableScopeWarning) {
+    if (!Object.keys(__webpack_require__.S).includes(SHARED_SCOPE_NAME)) {
+        throw new Error('Attempt to access share scope object before its initialization');
+    }
+    var sharedScope = __webpack_require__.S[SHARED_SCOPE_NAME];
+    if (enableScopeWarning) {
+        (0,_warnDuplicatePkg__WEBPACK_IMPORTED_MODULE_1__.warnDuplicatePkg)(sharedScope);
+    }
+    return sharedScope;
+};
+var handlePrefetchPromise = function (id, prefetch) {
+    if (prefetch) {
+        setPendingPrefetch(id, prefetch);
+        prefetch.finally(function () {
+            removePrefetch(id);
+        });
+    }
+};
+var getCachedModule = function (scope, module) {
+    var moduleId = getModuleIdentifier(scope, module);
+    try {
+        var cachedModule = getScalprum().exposedModules[moduleId];
+        if (!module) {
+            return {};
+        }
+        var prefetchID = scope + "#" + module;
+        var prefetchPromise = getPendingPrefetch(prefetchID);
+        if (prefetchPromise) {
+            return { cachedModule: cachedModule, prefetchPromise: prefetchPromise };
+        }
+        if (cachedModule === null || cachedModule === void 0 ? void 0 : cachedModule.prefetch) {
+            handlePrefetchPromise(prefetchID, cachedModule.prefetch(getScalprum().api));
+            return { cachedModule: cachedModule, prefetchPromise: getPendingPrefetch(prefetchID) };
+        }
+        return { cachedModule: cachedModule };
+    }
+    catch (error) {
+        console.warn("Unable to retrieve cached module " + scope + " " + module + ". New module will be loaded.", error);
+        return {};
+    }
+};
+var setPendingPrefetch = function (id, prefetch) {
+    getScalprum().pendingPrefetch[id] = prefetch;
+};
+var getPendingPrefetch = function (id) {
+    var _a;
+    return (_a = getScalprum().pendingPrefetch) === null || _a === void 0 ? void 0 : _a[id];
+};
+var removePrefetch = function (id) {
+    delete getScalprum().pendingPrefetch[id];
+};
+var resolvePendingInjection = function (id) {
+    delete getScalprum().pendingInjections[id];
+};
+var setPendingLoading = function (scope, module, promise) {
+    getScalprum().pendingLoading[scope + "#" + module] = promise;
+    promise
+        .then(function (data) {
+        delete getScalprum().pendingLoading[scope + "#" + module];
+        return data;
+    })
+        .catch(function () {
+        delete getScalprum().pendingLoading[scope + "#" + module];
+    });
+    return promise;
+};
+var getPendingLoading = function (scope, module) {
+    return getScalprum().pendingLoading[scope + "#" + module];
+};
+var preloadModule = function (scope, module, processor) { return __awaiter(void 0, void 0, void 0, function () {
+    var manifestLocation, cachedModule, modulePromise, prefetchID;
+    return __generator(this, function (_a) {
+        manifestLocation = getAppData(scope).manifestLocation;
+        cachedModule = getCachedModule(scope, module).cachedModule;
+        modulePromise = getPendingLoading(scope, module);
+        if (!modulePromise && Object.keys(cachedModule || {}).length == 0 && manifestLocation) {
+            modulePromise = processManifest(manifestLocation, scope, module, processor).then(function () { return getScalprum().pluginStore.getExposedModule(scope, module); });
+        }
+        prefetchID = scope + "#" + module;
+        if (!getPendingPrefetch(prefetchID) && (cachedModule === null || cachedModule === void 0 ? void 0 : cachedModule.prefetch)) {
+            handlePrefetchPromise(prefetchID, cachedModule.prefetch(getScalprum().api));
+        }
+        return [2, setPendingLoading(scope, module, Promise.resolve(modulePromise))];
+    });
+}); };
+var initialize = function (_a) {
+    var appsConfig = _a.appsConfig, api = _a.api, options = _a.options, _b = _a.pluginStoreFeatureFlags, pluginStoreFeatureFlags = _b === void 0 ? {} : _b, _c = _a.pluginLoaderOptions, pluginLoaderOptions = _c === void 0 ? {} : _c, _d = _a.pluginStoreOptions, pluginStoreOptions = _d === void 0 ? {} : _d;
+    if (scalprum) {
+        return scalprum;
+    }
+    var defaultOptions = __assign({ cacheTimeout: 120, enableScopeWarning: "development" === 'development' }, options);
+    var pluginLoader = new _openshift_dynamic_plugin_sdk__WEBPACK_IMPORTED_MODULE_0__.PluginLoader(__assign({ sharedScope: getSharedScope(defaultOptions.enableScopeWarning), getPluginEntryModule: function (_a) {
+            var name = _a.name;
+            return window[name];
+        } }, pluginLoaderOptions));
+    var pluginStore = new _openshift_dynamic_plugin_sdk__WEBPACK_IMPORTED_MODULE_0__.PluginStore(pluginStoreOptions);
+    pluginLoader.registerPluginEntryCallback();
+    pluginStore.setLoader(pluginLoader);
+    pluginStore.setFeatureFlags(pluginStoreFeatureFlags);
+    scalprum = {
+        appsConfig: appsConfig,
+        pendingInjections: {},
+        pendingLoading: {},
+        pendingPrefetch: {},
+        exposedModules: {},
+        scalprumOptions: defaultOptions,
+        api: api || {},
+        pluginStore: pluginStore,
+    };
+    return scalprum;
+};
+var removeScalprum = function () {
+    scalprum = undefined;
+};
+var getAppData = function (name) { return getScalprum().appsConfig[name]; };
+var setExposedModule = function (moduleId, exposedModule) {
+    getScalprum().exposedModules[moduleId] = exposedModule;
+};
+var clearPendingInjection = function (scope) {
+    delete getScalprum().pendingInjections[scope];
+};
+var setPendingInjection = function (scope, promise) {
+    getScalprum().pendingInjections[scope] = promise;
+};
+var getPendingInjection = function (scope) { return getScalprum().pendingInjections[scope]; };
+function isPluginManifest(manifest) {
+    return (typeof manifest.name === 'string' &&
+        typeof manifest.version === 'string' &&
+        Array.isArray(manifest.extensions) &&
+        Array.isArray(manifest.loadScripts));
+}
+function extractBaseURL(path) {
+    var result = path.split('/');
+    result.pop();
+    return result.join('/') || '/';
+}
+function processManifest(url, scope, module, processor) {
+    return __awaiter(this, void 0, void 0, function () {
+        var pendingInjection, pluginStore, exposedModule;
+        var _this = this;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    pendingInjection = getPendingInjection(scope);
+                    pluginStore = getScalprum().pluginStore;
+                    if (!pendingInjection) return [3, 3];
+                    return [4, pendingInjection];
+                case 1:
+                    _a.sent();
+                    return [4, pluginStore.getExposedModule(scope, module)];
+                case 2:
+                    exposedModule = _a.sent();
+                    setExposedModule(getModuleIdentifier(scope, module), exposedModule);
+                    return [2];
+                case 3:
+                    pendingInjection = (function () { return __awaiter(_this, void 0, void 0, function () {
+                        var headers, manifestPromise, resClone, data, error_1, manifest, error_2, sdkManifest, loadScripts, baseURL_1, exposedModule, error_3;
+                        return __generator(this, function (_a) {
+                            switch (_a.label) {
+                                case 0:
+                                    headers = new Headers();
+                                    headers.append('Pragma', 'no-cache');
+                                    headers.append('Cache-Control', 'no-cache');
+                                    headers.append('expires', '0');
+                                    return [4, fetch(url, {
+                                            method: 'GET',
+                                            headers: headers,
+                                        })];
+                                case 1:
+                                    manifestPromise = _a.sent();
+                                    if (!!manifestPromise.ok) return [3, 6];
+                                    resClone = manifestPromise.clone();
+                                    data = void 0;
+                                    _a.label = 2;
+                                case 2:
+                                    _a.trys.push([2, 4, , 5]);
+                                    return [4, resClone.json()];
+                                case 3:
+                                    data = _a.sent();
+                                    return [3, 5];
+                                case 4:
+                                    error_1 = _a.sent();
+                                    throw new Error("Unable to load manifest files at " + url + "! " + resClone.status + ": " + resClone.statusText);
+                                case 5: throw new Error("Unable to load manifest files at " + url + "! " + data);
+                                case 6:
+                                    _a.trys.push([6, 8, , 9]);
+                                    return [4, manifestPromise.json()];
+                                case 7:
+                                    manifest = _a.sent();
+                                    return [3, 9];
+                                case 8:
+                                    error_2 = _a.sent();
+                                    clearPendingInjection(scope);
+                                    throw new Error(error_2);
+                                case 9:
+                                    if (isPluginManifest(manifest)) {
+                                        sdkManifest = manifest;
+                                    }
+                                    else {
+                                        loadScripts = processor ? processor(manifest) : manifest[scope].entry;
+                                        baseURL_1 = extractBaseURL(loadScripts[0]);
+                                        sdkManifest = {
+                                            extensions: [],
+                                            loadScripts: loadScripts.map(function (script) { return script.replace(baseURL_1, ''); }),
+                                            name: scope,
+                                            registrationMethod: 'custom',
+                                            version: '1.0.0',
+                                            baseURL: baseURL_1,
+                                        };
+                                    }
+                                    return [4, pluginStore.loadPlugin(sdkManifest.baseURL, sdkManifest)];
+                                case 10:
+                                    _a.sent();
+                                    _a.label = 11;
+                                case 11:
+                                    _a.trys.push([11, 13, , 14]);
+                                    return [4, pluginStore.getExposedModule(scope, module)];
+                                case 12:
+                                    exposedModule = _a.sent();
+                                    setExposedModule(getModuleIdentifier(scope, module), exposedModule);
+                                    return [2];
+                                case 13:
+                                    error_3 = _a.sent();
+                                    clearPendingInjection(scope);
+                                    throw error_3;
+                                case 14: return [2];
+                            }
+                        });
+                    }); })();
+                    setPendingInjection(scope, pendingInjection);
+                    return [4, pendingInjection];
+                case 4:
+                    _a.sent();
+                    clearPendingInjection(scope);
+                    return [2];
+            }
+        });
+    });
+}
+//# sourceMappingURL=index.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@scalprum/core/dist/esm/warnDuplicatePkg.js":
+/*!******************************************************************!*\
+  !*** ./node_modules/@scalprum/core/dist/esm/warnDuplicatePkg.js ***!
+  \******************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "warnDuplicatePkg": () => (/* binding */ warnDuplicatePkg)
+/* harmony export */ });
+var warnDuplicatePkg = function (packages) {
+    var entries = Object.entries(packages);
+    entries.forEach(function (_a) {
+        var pkgName = _a[0], versions = _a[1];
+        var instances = Object.keys(versions);
+        if (instances.length > 1) {
+            console.warn("[SCALPRUM]: You have " + pkgName + " package that is being loaded into browser multiple times. You might want to align your version with the chrome one.");
+            console.warn("[SCALPRUM]: All packages instances:", versions);
+        }
+    });
+};
+//# sourceMappingURL=warnDuplicatePkg.js.map
+
+/***/ })
+
+}]);