You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@superset.apache.org by as...@apache.org on 2026/02/18 12:49:21 UTC
(superset) branch alexandrusoare/refactor/passwords-yaml-config created (now ba7be015eb0)
This is an automated email from the ASF dual-hosted git repository.
asoare pushed a change to branch alexandrusoare/refactor/passwords-yaml-config
in repository https://gitbox.apache.org/repos/asf/superset.git
at ba7be015eb0 refactor(passwords): accept passwords via YAML file
This branch includes the following new commits:
new ba7be015eb0 refactor(passwords): accept passwords via YAML file
The 1 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails. The revisions
listed as "add" were already present in the repository and have only
been added to this reference.
(superset) 01/01: refactor(passwords): accept passwords via YAML file
Posted by as...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
asoare pushed a commit to branch alexandrusoare/refactor/passwords-yaml-config
in repository https://gitbox.apache.org/repos/asf/superset.git
commit ba7be015eb07497ef5c643577025ff156910828e
Author: alexandrusoare <al...@gmail.com>
AuthorDate: Wed Feb 18 14:48:14 2026 +0200
refactor(passwords): accept passwords via YAML file
---
superset/commands/importers/v1/utils.py | 6 +-
superset/static/service-worker.js | 1492 +++++++++++++++++++-
.../databases/importers/v1/command_test.py | 40 +
3 files changed, 1513 insertions(+), 25 deletions(-)
diff --git a/superset/commands/importers/v1/utils.py b/superset/commands/importers/v1/utils.py
index 3aeb586997c..15f9009e6be 100644
--- a/superset/commands/importers/v1/utils.py
+++ b/superset/commands/importers/v1/utils.py
@@ -149,9 +149,13 @@ def load_configs(
try:
config = load_yaml(file_name, content)
- # populate passwords from the request or from existing DBs
+ # populate passwords from the request, from YAML config,
+ # or from existing DBs
if file_name in passwords:
config["password"] = passwords[file_name]
+ elif prefix == "databases" and config.get("password"):
+ # password already in YAML config, keep it
+ pass
elif prefix == "databases" and config["uuid"] in db_passwords:
config["password"] = db_passwords[config["uuid"]]
diff --git a/superset/static/service-worker.js b/superset/static/service-worker.js
index 43cb14a4894..11db92f0549 100644
--- a/superset/static/service-worker.js
+++ b/superset/static/service-worker.js
@@ -1,27 +1,1471 @@
-/**
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
+/*
+ * ATTENTION: An "eval-source-map" devtool has been used.
+ * This devtool is neither made for production nor for readable output files.
+ * It uses "eval()" calls to create a separate source file with attached SourceMaps in the browser devtools.
+ * If you are trying to read the output file, select a different devtool (https://webpack.js.org/configuration/devtool/)
+ * or disable the default devtool with "devtool: false".
+ * If you are looking for production-ready output files, see mode: "production" (https://webpack.js.org/configuration/mode/).
*/
+/******/ (() => { // webpackBootstrap
+/******/ "use strict";
+/******/ var __webpack_modules__ = ({
-// Minimal service worker for PWA file handling support
-self.addEventListener('install', event => {
- event.waitUntil(self.skipWaiting());
-});
+/***/ "./src/service-worker.ts"
+/*!*******************************!*\
+ !*** ./src/service-worker.ts ***!
+ \*******************************/
+() {
-self.addEventListener('activate', event => {
- event.waitUntil(self.clients.claim());
-});
+eval("{/**\n * Licensed to the Apache Software Foundation (ASF) under one\n * or more contributor license agreements. See the NOTICE file\n * distributed with this work for additional information\n * regarding copyright ownership. The ASF licenses this file\n * to you under the Apache License, Version 2.0 (the\n * \"License\"); you may not use this file except in compliance\n * with the License. You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2 [...]
+
+/***/ }
+
+/******/ });
+/************************************************************************/
+/******/ // The module cache
+/******/ var __webpack_module_cache__ = {};
+/******/
+/******/ // The require function
+/******/ function __webpack_require__(moduleId) {
+/******/ // Check if module is in cache
+/******/ var cachedModule = __webpack_module_cache__[moduleId];
+/******/ if (cachedModule !== undefined) {
+/******/ return cachedModule.exports;
+/******/ }
+/******/ // Check if module exists (development only)
+/******/ if (__webpack_modules__[moduleId] === undefined) {
+/******/ var e = new Error("Cannot find module '" + moduleId + "'");
+/******/ e.code = 'MODULE_NOT_FOUND';
+/******/ throw e;
+/******/ }
+/******/ // Create a new module (and put it into the cache)
+/******/ var module = __webpack_module_cache__[moduleId] = {
+/******/ id: moduleId,
+/******/ loaded: false,
+/******/ exports: {}
+/******/ };
+/******/
+/******/ // Execute the module function
+/******/ var execOptions = { id: moduleId, module: module, factory: __webpack_modules__[moduleId], require: __webpack_require__ };
+/******/ __webpack_require__.i.forEach(function(handler) { handler(execOptions); });
+/******/ module = execOptions.module;
+/******/ execOptions.factory.call(module.exports, module, module.exports, execOptions.require);
+/******/
+/******/ // Flag the module as loaded
+/******/ module.loaded = true;
+/******/
+/******/ // Return the exports of the module
+/******/ return module.exports;
+/******/ }
+/******/
+/******/ // expose the modules object (__webpack_modules__)
+/******/ __webpack_require__.m = __webpack_modules__;
+/******/
+/******/ // expose the module cache
+/******/ __webpack_require__.c = __webpack_module_cache__;
+/******/
+/******/ // expose the module execution interceptor
+/******/ __webpack_require__.i = [];
+/******/
+/************************************************************************/
+/******/ /* webpack/runtime/chunk loaded */
+/******/ (() => {
+/******/ var deferred = [];
+/******/ __webpack_require__.O = (result, chunkIds, fn, priority) => {
+/******/ if(chunkIds) {
+/******/ priority = priority || 0;
+/******/ for(var i = deferred.length; i > 0 && deferred[i - 1][2] > priority; i--) deferred[i] = deferred[i - 1];
+/******/ deferred[i] = [chunkIds, fn, priority];
+/******/ return;
+/******/ }
+/******/ var notFulfilled = Infinity;
+/******/ for (var i = 0; i < deferred.length; i++) {
+/******/ var [chunkIds, fn, priority] = deferred[i];
+/******/ var fulfilled = true;
+/******/ for (var j = 0; j < chunkIds.length; j++) {
+/******/ if ((priority & 1 === 0 || notFulfilled >= priority) && Object.keys(__webpack_require__.O).every((key) => (__webpack_require__.O[key](chunkIds[j])))) {
+/******/ chunkIds.splice(j--, 1);
+/******/ } else {
+/******/ fulfilled = false;
+/******/ if(priority < notFulfilled) notFulfilled = priority;
+/******/ }
+/******/ }
+/******/ if(fulfilled) {
+/******/ deferred.splice(i--, 1)
+/******/ var r = fn();
+/******/ if (r !== undefined) result = r;
+/******/ }
+/******/ }
+/******/ return result;
+/******/ };
+/******/ })();
+/******/
+/******/ /* webpack/runtime/compat get default export */
+/******/ (() => {
+/******/ // getDefaultExport function for compatibility with non-harmony modules
+/******/ __webpack_require__.n = (module) => {
+/******/ var getter = module && module.__esModule ?
+/******/ () => (module['default']) :
+/******/ () => (module);
+/******/ __webpack_require__.d(getter, { a: getter });
+/******/ return getter;
+/******/ };
+/******/ })();
+/******/
+/******/ /* webpack/runtime/create fake namespace object */
+/******/ (() => {
+/******/ var getProto = Object.getPrototypeOf ? (obj) => (Object.getPrototypeOf(obj)) : (obj) => (obj.__proto__);
+/******/ var leafPrototypes;
+/******/ // create a fake namespace object
+/******/ // mode & 1: value is a module id, require it
+/******/ // mode & 2: merge all properties of value into the ns
+/******/ // mode & 4: return value when already ns object
+/******/ // mode & 16: return value when it's Promise-like
+/******/ // mode & 8|1: behave like require
+/******/ __webpack_require__.t = function(value, mode) {
+/******/ if(mode & 1) value = this(value);
+/******/ if(mode & 8) return value;
+/******/ if(typeof value === 'object' && value) {
+/******/ if((mode & 4) && value.__esModule) return value;
+/******/ if((mode & 16) && typeof value.then === 'function') return value;
+/******/ }
+/******/ var ns = Object.create(null);
+/******/ __webpack_require__.r(ns);
+/******/ var def = {};
+/******/ leafPrototypes = leafPrototypes || [null, getProto({}), getProto([]), getProto(getProto)];
+/******/ for(var current = mode & 2 && value; (typeof current == 'object' || typeof current == 'function') && !~leafPrototypes.indexOf(current); current = getProto(current)) {
+/******/ Object.getOwnPropertyNames(current).forEach((key) => (def[key] = () => (value[key])));
+/******/ }
+/******/ def['default'] = () => (value);
+/******/ __webpack_require__.d(ns, def);
+/******/ return ns;
+/******/ };
+/******/ })();
+/******/
+/******/ /* webpack/runtime/define property getters */
+/******/ (() => {
+/******/ // define getter functions for harmony exports
+/******/ __webpack_require__.d = (exports, definition) => {
+/******/ for(var key in definition) {
+/******/ if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
+/******/ Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
+/******/ }
+/******/ }
+/******/ };
+/******/ })();
+/******/
+/******/ /* webpack/runtime/get javascript update chunk filename */
+/******/ (() => {
+/******/ // This function allow to reference all chunks
+/******/ __webpack_require__.hu = (chunkId) => {
+/******/ // return url for filenames based on template
+/******/ return "" + chunkId + "." + __webpack_require__.h() + ".hot-update.js";
+/******/ };
+/******/ })();
+/******/
+/******/ /* webpack/runtime/get update manifest filename */
+/******/ (() => {
+/******/ __webpack_require__.hmrF = () => ("service-worker." + __webpack_require__.h() + ".hot-update.json");
+/******/ })();
+/******/
+/******/ /* webpack/runtime/getFullHash */
+/******/ (() => {
+/******/ __webpack_require__.h = () => ("b31f938b59403270fa11")
+/******/ })();
+/******/
+/******/ /* webpack/runtime/harmony module decorator */
+/******/ (() => {
+/******/ __webpack_require__.hmd = (module) => {
+/******/ module = Object.create(module);
+/******/ if (!module.children) module.children = [];
+/******/ Object.defineProperty(module, 'exports', {
+/******/ enumerable: true,
+/******/ set: () => {
+/******/ throw new Error('ES Modules may not assign module.exports or exports.*, Use ESM export syntax, instead: ' + module.id);
+/******/ }
+/******/ });
+/******/ return module;
+/******/ };
+/******/ })();
+/******/
+/******/ /* webpack/runtime/hasOwnProperty shorthand */
+/******/ (() => {
+/******/ __webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
+/******/ })();
+/******/
+/******/ /* webpack/runtime/load script */
+/******/ (() => {
+/******/ var inProgress = {};
+/******/ var dataWebpackPrefix = "superset:";
+/******/ // loadScript function to load a script via script tag
+/******/ __webpack_require__.l = (url, done, key, chunkId) => {
+/******/ if(inProgress[url]) { inProgress[url].push(done); return; }
+/******/ var script, needAttach;
+/******/ if(key !== undefined) {
+/******/ var scripts = document.getElementsByTagName("script");
+/******/ for(var i = 0; i < scripts.length; i++) {
+/******/ var s = scripts[i];
+/******/ if(s.getAttribute("src") == url || s.getAttribute("data-webpack") == dataWebpackPrefix + key) { script = s; break; }
+/******/ }
+/******/ }
+/******/ if(!script) {
+/******/ needAttach = true;
+/******/ script = document.createElement('script');
+/******/
+/******/ script.charset = 'utf-8';
+/******/ if (__webpack_require__.nc) {
+/******/ script.setAttribute("nonce", __webpack_require__.nc);
+/******/ }
+/******/ script.setAttribute("data-webpack", dataWebpackPrefix + key);
+/******/
+/******/ script.src = url;
+/******/ }
+/******/ inProgress[url] = [done];
+/******/ var onScriptComplete = (prev, event) => {
+/******/ // avoid mem leaks in IE.
+/******/ script.onerror = script.onload = null;
+/******/ clearTimeout(timeout);
+/******/ var doneFns = inProgress[url];
+/******/ delete inProgress[url];
+/******/ script.parentNode && script.parentNode.removeChild(script);
+/******/ doneFns && doneFns.forEach((fn) => (fn(event)));
+/******/ if(prev) return prev(event);
+/******/ }
+/******/ var timeout = setTimeout(onScriptComplete.bind(null, undefined, { type: 'timeout', target: script }), 120000);
+/******/ script.onerror = onScriptComplete.bind(null, script.onerror);
+/******/ script.onload = onScriptComplete.bind(null, script.onload);
+/******/ needAttach && document.head.appendChild(script);
+/******/ };
+/******/ })();
+/******/
+/******/ /* webpack/runtime/make namespace object */
+/******/ (() => {
+/******/ // define __esModule on exports
+/******/ __webpack_require__.r = (exports) => {
+/******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+/******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+/******/ }
+/******/ Object.defineProperty(exports, '__esModule', { value: true });
+/******/ };
+/******/ })();
+/******/
+/******/ /* webpack/runtime/node module decorator */
+/******/ (() => {
+/******/ __webpack_require__.nmd = (module) => {
+/******/ module.paths = [];
+/******/ if (!module.children) module.children = [];
+/******/ return module;
+/******/ };
+/******/ })();
+/******/
+/******/ /* webpack/runtime/sharing */
+/******/ (() => {
+/******/ __webpack_require__.S = {};
+/******/ var initPromises = {};
+/******/ var initTokens = {};
+/******/ __webpack_require__.I = (name, initScope) => {
+/******/ if(!initScope) initScope = [];
+/******/ // handling circular init calls
+/******/ var initToken = initTokens[name];
+/******/ if(!initToken) initToken = initTokens[name] = {};
+/******/ if(initScope.indexOf(initToken) >= 0) return;
+/******/ initScope.push(initToken);
+/******/ // only runs once
+/******/ if(initPromises[name]) return initPromises[name];
+/******/ // creates a new share scope if needed
+/******/ if(!__webpack_require__.o(__webpack_require__.S, name)) __webpack_require__.S[name] = {};
+/******/ // runs all init snippets from all modules reachable
+/******/ var scope = __webpack_require__.S[name];
+/******/ var warn = (msg) => {
+/******/ if (typeof console !== "undefined" && console.warn) console.warn(msg);
+/******/ };
+/******/ var uniqueName = "superset";
+/******/ var register = (name, version, factory, eager) => {
+/******/ var versions = scope[name] = scope[name] || {};
+/******/ var activeVersion = versions[version];
+/******/ if(!activeVersion || (!activeVersion.loaded && (!eager != !activeVersion.eager ? eager : uniqueName > activeVersion.from))) versions[version] = { get: factory, from: uniqueName, eager: !!eager };
+/******/ };
+/******/ var initExternal = (id) => {
+/******/ var handleError = (err) => (warn("Initialization of sharing external failed: " + err));
+/******/ try {
+/******/ var module = __webpack_require__(id);
+/******/ if(!module) return;
+/******/ var initFn = (module) => (module && module.init && module.init(__webpack_require__.S[name], initScope))
+/******/ if(module.then) return promises.push(module.then(initFn, handleError));
+/******/ var initResult = initFn(module);
+/******/ if(initResult && initResult.then) return promises.push(initResult['catch'](handleError));
+/******/ } catch(err) { handleError(err); }
+/******/ }
+/******/ var promises = [];
+/******/ switch(name) {
+/******/ case "default": {
+/******/ register("antd", "5.27.6", () => (() => (__webpack_require__(/*! ./node_modules/antd/es/index.js */ "./node_modules/antd/es/index.js"))), 1);
+/******/ register("react-dom", "17.0.2", () => (() => (__webpack_require__(/*! ./node_modules/react-dom/index.js */ "./node_modules/react-dom/index.js"))), 1);
+/******/ register("react", "17.0.2", () => (() => (__webpack_require__(/*! ./node_modules/react/index.js */ "./node_modules/react/index.js"))), 1);
+/******/ }
+/******/ break;
+/******/ }
+/******/ if(!promises.length) return initPromises[name] = 1;
+/******/ return initPromises[name] = Promise.all(promises).then(() => (initPromises[name] = 1));
+/******/ };
+/******/ })();
+/******/
+/******/ /* webpack/runtime/hot module replacement */
+/******/ (() => {
+/******/ var currentModuleData = {};
+/******/ var installedModules = __webpack_require__.c;
+/******/
+/******/ // module and require creation
+/******/ var currentChildModule;
+/******/ var currentParents = [];
+/******/
+/******/ // status
+/******/ var registeredStatusHandlers = [];
+/******/ var currentStatus = "idle";
+/******/
+/******/ // while downloading
+/******/ var blockingPromises = 0;
+/******/ var blockingPromisesWaiting = [];
+/******/
+/******/ // The update info
+/******/ var currentUpdateApplyHandlers;
+/******/ var queuedInvalidatedModules;
+/******/
+/******/ __webpack_require__.hmrD = currentModuleData;
+/******/
+/******/ __webpack_require__.i.push(function (options) {
+/******/ var module = options.module;
+/******/ var require = createRequire(options.require, options.id);
+/******/ module.hot = createModuleHotObject(options.id, module);
+/******/ module.parents = currentParents;
+/******/ module.children = [];
+/******/ currentParents = [];
+/******/ options.require = require;
+/******/ });
+/******/
+/******/ __webpack_require__.hmrC = {};
+/******/ __webpack_require__.hmrI = {};
+/******/
+/******/ function createRequire(require, moduleId) {
+/******/ var me = installedModules[moduleId];
+/******/ if (!me) return require;
+/******/ var fn = function (request) {
+/******/ if (me.hot.active) {
+/******/ if (installedModules[request]) {
+/******/ var parents = installedModules[request].parents;
+/******/ if (parents.indexOf(moduleId) === -1) {
+/******/ parents.push(moduleId);
+/******/ }
+/******/ } else {
+/******/ currentParents = [moduleId];
+/******/ currentChildModule = request;
+/******/ }
+/******/ if (me.children.indexOf(request) === -1) {
+/******/ me.children.push(request);
+/******/ }
+/******/ } else {
+/******/ console.warn(
+/******/ "[HMR] unexpected require(" +
+/******/ request +
+/******/ ") from disposed module " +
+/******/ moduleId
+/******/ );
+/******/ currentParents = [];
+/******/ }
+/******/ return require(request);
+/******/ };
+/******/ var createPropertyDescriptor = function (name) {
+/******/ return {
+/******/ configurable: true,
+/******/ enumerable: true,
+/******/ get: function () {
+/******/ return require[name];
+/******/ },
+/******/ set: function (value) {
+/******/ require[name] = value;
+/******/ }
+/******/ };
+/******/ };
+/******/ for (var name in require) {
+/******/ if (Object.prototype.hasOwnProperty.call(require, name) && name !== "e") {
+/******/ Object.defineProperty(fn, name, createPropertyDescriptor(name));
+/******/ }
+/******/ }
+/******/ fn.e = function (chunkId, fetchPriority) {
+/******/ return trackBlockingPromise(require.e(chunkId, fetchPriority));
+/******/ };
+/******/ return fn;
+/******/ }
+/******/
+/******/ function createModuleHotObject(moduleId, me) {
+/******/ var _main = currentChildModule !== moduleId;
+/******/ var hot = {
+/******/ // private stuff
+/******/ _acceptedDependencies: {},
+/******/ _acceptedErrorHandlers: {},
+/******/ _declinedDependencies: {},
+/******/ _selfAccepted: false,
+/******/ _selfDeclined: false,
+/******/ _selfInvalidated: false,
+/******/ _disposeHandlers: [],
+/******/ _main: _main,
+/******/ _requireSelf: function () {
+/******/ currentParents = me.parents.slice();
+/******/ currentChildModule = _main ? undefined : moduleId;
+/******/ __webpack_require__(moduleId);
+/******/ },
+/******/
+/******/ // Module API
+/******/ active: true,
+/******/ accept: function (dep, callback, errorHandler) {
+/******/ if (dep === undefined) hot._selfAccepted = true;
+/******/ else if (typeof dep === "function") hot._selfAccepted = dep;
+/******/ else if (typeof dep === "object" && dep !== null) {
+/******/ for (var i = 0; i < dep.length; i++) {
+/******/ hot._acceptedDependencies[dep[i]] = callback || function () {};
+/******/ hot._acceptedErrorHandlers[dep[i]] = errorHandler;
+/******/ }
+/******/ } else {
+/******/ hot._acceptedDependencies[dep] = callback || function () {};
+/******/ hot._acceptedErrorHandlers[dep] = errorHandler;
+/******/ }
+/******/ },
+/******/ decline: function (dep) {
+/******/ if (dep === undefined) hot._selfDeclined = true;
+/******/ else if (typeof dep === "object" && dep !== null)
+/******/ for (var i = 0; i < dep.length; i++)
+/******/ hot._declinedDependencies[dep[i]] = true;
+/******/ else hot._declinedDependencies[dep] = true;
+/******/ },
+/******/ dispose: function (callback) {
+/******/ hot._disposeHandlers.push(callback);
+/******/ },
+/******/ addDisposeHandler: function (callback) {
+/******/ hot._disposeHandlers.push(callback);
+/******/ },
+/******/ removeDisposeHandler: function (callback) {
+/******/ var idx = hot._disposeHandlers.indexOf(callback);
+/******/ if (idx >= 0) hot._disposeHandlers.splice(idx, 1);
+/******/ },
+/******/ invalidate: function () {
+/******/ this._selfInvalidated = true;
+/******/ switch (currentStatus) {
+/******/ case "idle":
+/******/ currentUpdateApplyHandlers = [];
+/******/ Object.keys(__webpack_require__.hmrI).forEach(function (key) {
+/******/ __webpack_require__.hmrI[key](
+/******/ moduleId,
+/******/ currentUpdateApplyHandlers
+/******/ );
+/******/ });
+/******/ setStatus("ready");
+/******/ break;
+/******/ case "ready":
+/******/ Object.keys(__webpack_require__.hmrI).forEach(function (key) {
+/******/ __webpack_require__.hmrI[key](
+/******/ moduleId,
+/******/ currentUpdateApplyHandlers
+/******/ );
+/******/ });
+/******/ break;
+/******/ case "prepare":
+/******/ case "check":
+/******/ case "dispose":
+/******/ case "apply":
+/******/ (queuedInvalidatedModules = queuedInvalidatedModules || []).push(
+/******/ moduleId
+/******/ );
+/******/ break;
+/******/ default:
+/******/ // ignore requests in error states
+/******/ break;
+/******/ }
+/******/ },
+/******/
+/******/ // Management API
+/******/ check: hotCheck,
+/******/ apply: hotApply,
+/******/ status: function (l) {
+/******/ if (!l) return currentStatus;
+/******/ registeredStatusHandlers.push(l);
+/******/ },
+/******/ addStatusHandler: function (l) {
+/******/ registeredStatusHandlers.push(l);
+/******/ },
+/******/ removeStatusHandler: function (l) {
+/******/ var idx = registeredStatusHandlers.indexOf(l);
+/******/ if (idx >= 0) registeredStatusHandlers.splice(idx, 1);
+/******/ },
+/******/
+/******/ // inherit from previous dispose call
+/******/ data: currentModuleData[moduleId]
+/******/ };
+/******/ currentChildModule = undefined;
+/******/ return hot;
+/******/ }
+/******/
+/******/ function setStatus(newStatus) {
+/******/ currentStatus = newStatus;
+/******/ var results = [];
+/******/
+/******/ for (var i = 0; i < registeredStatusHandlers.length; i++)
+/******/ results[i] = registeredStatusHandlers[i].call(null, newStatus);
+/******/
+/******/ return Promise.all(results).then(function () {});
+/******/ }
+/******/
+/******/ function unblock() {
+/******/ if (--blockingPromises === 0) {
+/******/ setStatus("ready").then(function () {
+/******/ if (blockingPromises === 0) {
+/******/ var list = blockingPromisesWaiting;
+/******/ blockingPromisesWaiting = [];
+/******/ for (var i = 0; i < list.length; i++) {
+/******/ list[i]();
+/******/ }
+/******/ }
+/******/ });
+/******/ }
+/******/ }
+/******/
+/******/ function trackBlockingPromise(promise) {
+/******/ switch (currentStatus) {
+/******/ case "ready":
+/******/ setStatus("prepare");
+/******/ /* fallthrough */
+/******/ case "prepare":
+/******/ blockingPromises++;
+/******/ promise.then(unblock, unblock);
+/******/ return promise;
+/******/ default:
+/******/ return promise;
+/******/ }
+/******/ }
+/******/
+/******/ function waitForBlockingPromises(fn) {
+/******/ if (blockingPromises === 0) return fn();
+/******/ return new Promise(function (resolve) {
+/******/ blockingPromisesWaiting.push(function () {
+/******/ resolve(fn());
+/******/ });
+/******/ });
+/******/ }
+/******/
+/******/ function hotCheck(applyOnUpdate) {
+/******/ if (currentStatus !== "idle") {
+/******/ throw new Error("check() is only allowed in idle status");
+/******/ }
+/******/ return setStatus("check")
+/******/ .then(__webpack_require__.hmrM)
+/******/ .then(function (update) {
+/******/ if (!update) {
+/******/ return setStatus(applyInvalidatedModules() ? "ready" : "idle").then(
+/******/ function () {
+/******/ return null;
+/******/ }
+/******/ );
+/******/ }
+/******/
+/******/ return setStatus("prepare").then(function () {
+/******/ var updatedModules = [];
+/******/ currentUpdateApplyHandlers = [];
+/******/
+/******/ return Promise.all(
+/******/ Object.keys(__webpack_require__.hmrC).reduce(function (
+/******/ promises,
+/******/ key
+/******/ ) {
+/******/ __webpack_require__.hmrC[key](
+/******/ update.c,
+/******/ update.r,
+/******/ update.m,
+/******/ promises,
+/******/ currentUpdateApplyHandlers,
+/******/ updatedModules,
+/******/ update.css
+/******/ );
+/******/ return promises;
+/******/ }, [])
+/******/ ).then(function () {
+/******/ return waitForBlockingPromises(function () {
+/******/ if (applyOnUpdate) {
+/******/ return internalApply(applyOnUpdate);
+/******/ }
+/******/ return setStatus("ready").then(function () {
+/******/ return updatedModules;
+/******/ });
+/******/ });
+/******/ });
+/******/ });
+/******/ });
+/******/ }
+/******/
+/******/ function hotApply(options) {
+/******/ if (currentStatus !== "ready") {
+/******/ return Promise.resolve().then(function () {
+/******/ throw new Error(
+/******/ "apply() is only allowed in ready status (state: " +
+/******/ currentStatus +
+/******/ ")"
+/******/ );
+/******/ });
+/******/ }
+/******/ return internalApply(options);
+/******/ }
+/******/
+/******/ function internalApply(options) {
+/******/ options = options || {};
+/******/
+/******/ applyInvalidatedModules();
+/******/
+/******/ var results = currentUpdateApplyHandlers.map(function (handler) {
+/******/ return handler(options);
+/******/ });
+/******/ currentUpdateApplyHandlers = undefined;
+/******/
+/******/ var errors = results
+/******/ .map(function (r) {
+/******/ return r.error;
+/******/ })
+/******/ .filter(Boolean);
+/******/
+/******/ if (errors.length > 0) {
+/******/ return setStatus("abort").then(function () {
+/******/ throw errors[0];
+/******/ });
+/******/ }
+/******/
+/******/ // Now in "dispose" phase
+/******/ var disposePromise = setStatus("dispose");
+/******/
+/******/ results.forEach(function (result) {
+/******/ if (result.dispose) result.dispose();
+/******/ });
+/******/
+/******/ // Now in "apply" phase
+/******/ var applyPromise = setStatus("apply");
+/******/
+/******/ var error;
+/******/ var reportError = function (err) {
+/******/ if (!error) error = err;
+/******/ };
+/******/
+/******/ var outdatedModules = [];
+/******/
+/******/ var onAccepted = function () {
+/******/ return Promise.all([disposePromise, applyPromise]).then(function () {
+/******/ // handle errors in accept handlers and self accepted module load
+/******/ if (error) {
+/******/ return setStatus("fail").then(function () {
+/******/ throw error;
+/******/ });
+/******/ }
+/******/
+/******/ if (queuedInvalidatedModules) {
+/******/ return internalApply(options).then(function (list) {
+/******/ outdatedModules.forEach(function (moduleId) {
+/******/ if (list.indexOf(moduleId) < 0) list.push(moduleId);
+/******/ });
+/******/ return list;
+/******/ });
+/******/ }
+/******/
+/******/ return setStatus("idle").then(function () {
+/******/ return outdatedModules;
+/******/ });
+/******/ });
+/******/ };
+/******/
+/******/ return Promise.all(
+/******/ results
+/******/ .filter(function (result) {
+/******/ return result.apply;
+/******/ })
+/******/ .map(function (result) {
+/******/ return result.apply(reportError);
+/******/ })
+/******/ )
+/******/ .then(function (applyResults) {
+/******/ applyResults.forEach(function (modules) {
+/******/ if (modules) {
+/******/ for (var i = 0; i < modules.length; i++) {
+/******/ outdatedModules.push(modules[i]);
+/******/ }
+/******/ }
+/******/ });
+/******/ })
+/******/ .then(onAccepted);
+/******/ }
+/******/
+/******/ function applyInvalidatedModules() {
+/******/ if (queuedInvalidatedModules) {
+/******/ if (!currentUpdateApplyHandlers) currentUpdateApplyHandlers = [];
+/******/ Object.keys(__webpack_require__.hmrI).forEach(function (key) {
+/******/ queuedInvalidatedModules.forEach(function (moduleId) {
+/******/ __webpack_require__.hmrI[key](
+/******/ moduleId,
+/******/ currentUpdateApplyHandlers
+/******/ );
+/******/ });
+/******/ });
+/******/ queuedInvalidatedModules = undefined;
+/******/ return true;
+/******/ }
+/******/ }
+/******/ })();
+/******/
+/******/ /* webpack/runtime/publicPath */
+/******/ (() => {
+/******/ __webpack_require__.p = "/static/assets/";
+/******/ })();
+/******/
+/******/ /* webpack/runtime/react refresh */
+/******/ (() => {
+/******/ const setup = (moduleId) => {
+/******/ const refresh = {
+/******/ moduleId: moduleId,
+/******/ register: (type, id) => {
+/******/ const typeId = moduleId + ' ' + id;
+/******/ refresh.runtime.register(type, typeId);
+/******/ },
+/******/ signature: () => (refresh.runtime.createSignatureFunctionForTransform()),
+/******/ runtime: {
+/******/ createSignatureFunctionForTransform: () => ((type) => (type)),
+/******/ register: x => {}
+/******/ },
+/******/ };
+/******/ return refresh;
+/******/ };
+/******/
+/******/ __webpack_require__.i.push((options) => {
+/******/ const originalFactory = options.factory;
+/******/ options.factory = function(moduleObject, moduleExports, webpackRequire) {
+/******/ const hotRequire = (request) => (webpackRequire(request));
+/******/ const createPropertyDescriptor = (name) => {
+/******/ return {
+/******/ configurable: true,
+/******/ enumerable: true,
+/******/ get: () => (webpackRequire[name]),
+/******/ set: (value) => {
+/******/ webpackRequire[name] = value;
+/******/ },
+/******/ };
+/******/ };
+/******/ for (const name in webpackRequire) {
+/******/ if (name === "$Refresh$") continue;
+/******/ if (Object.prototype.hasOwnProperty.call(webpackRequire, name)) {
+/******/ Object.defineProperty(hotRequire, name, createPropertyDescriptor(name));
+/******/ }
+/******/ }
+/******/ hotRequire.$Refresh$ = setup(options.id);
+/******/ originalFactory.call(this, moduleObject, moduleExports, hotRequire);
+/******/ };
+/******/ });
+/******/ })();
+/******/
+/******/ /* webpack/runtime/consumes */
+/******/ (() => {
+/******/ var parseVersion = (str) => {
+/******/ // see webpack/lib/util/semver.js for original code
+/******/ var p=p=>{return p.split(".").map(p=>{return+p==p?+p:p})},n=/^([^-+]+)?(?:-([^+]+))?(?:\+(.+))?$/.exec(str),r=n[1]?p(n[1]):[];return n[2]&&(r.length++,r.push.apply(r,p(n[2]))),n[3]&&(r.push([]),r.push.apply(r,p(n[3]))),r;
+/******/ }
+/******/ var versionLt = (a, b) => {
+/******/ // see webpack/lib/util/semver.js for original code
+/******/ a=parseVersion(a),b=parseVersion(b);for(var r=0;;){if(r>=a.length)return r<b.length&&"u"!=(typeof b[r])[0];var e=a[r],n=(typeof e)[0];if(r>=b.length)return"u"==n;var t=b[r],f=(typeof t)[0];if(n!=f)return"o"==n&&"n"==f||("s"==f||"u"==n);if("o"!=n&&"u"!=n&&e!=t)return e<t;r++}
+/******/ }
+/******/ var rangeToString = (range) => {
+/******/ // see webpack/lib/util/semver.js for original code
+/******/ var r=range[0],n="";if(1===range.length)return"*";if(r+.5){n+=0==r?">=":-1==r?"<":1==r?"^":2==r?"~":r>0?"=":"!=";for(var e=1,a=1;a<range.length;a++){e--,n+="u"==(typeof(t=range[a]))[0]?"-":(e>0?".":"")+(e=2,t)}return n}var g=[];for(a=1;a<range.length;a++){var t=range[a];g.push(0===t?"not("+o()+")":1===t?"("+o()+" || "+o()+")":2===t?g.pop()+" "+g.pop():rangeToString(t))}return o();function o(){return g.pop().replace(/^\((.+)\)$/,"$1")}
+/******/ }
+/******/ var satisfy = (range, version) => {
+/******/ // see webpack/lib/util/semver.js for original code
+/******/ if(0 in range){version=parseVersion(version);var e=range[0],r=e<0;r&&(e=-e-1);for(var n=0,i=1,a=!0;;i++,n++){var f,s,g=i<range.length?(typeof range[i])[0]:"";if(n>=version.length||"o"==(s=(typeof(f=version[n]))[0]))return!a||("u"==g?i>e&&!r:""==g!=r);if("u"==s){if(!a||"u"!=g)return!1}else if(a)if(g==s)if(i<=e){if(f!=range[i])return!1}else{if(r?f>range[i]:f<range[i])return!1;f!=range[i]&&(a=!1)}else if("s"!=g&&"n"!=g){if(r||i<=e)return!1;a=!1,i--}else{if(i<=e||s<g!=r)return!1; [...]
+/******/ }
+/******/ var exists = (scope, key) => {
+/******/ return scope && __webpack_require__.o(scope, key);
+/******/ }
+/******/ var get = (entry) => {
+/******/ entry.loaded = 1;
+/******/ return entry.get()
+/******/ };
+/******/ var eagerOnly = (versions) => {
+/******/ return Object.keys(versions).reduce((filtered, version) => {
+/******/ if (versions[version].eager) {
+/******/ filtered[version] = versions[version];
+/******/ }
+/******/ return filtered;
+/******/ }, {});
+/******/ };
+/******/ var findLatestVersion = (scope, key, eager) => {
+/******/ var versions = eager ? eagerOnly(scope[key]) : scope[key];
+/******/ var key = Object.keys(versions).reduce((a, b) => {
+/******/ return !a || versionLt(a, b) ? b : a;
+/******/ }, 0);
+/******/ return key && versions[key];
+/******/ };
+/******/ var findSatisfyingVersion = (scope, key, requiredVersion, eager) => {
+/******/ var versions = eager ? eagerOnly(scope[key]) : scope[key];
+/******/ var key = Object.keys(versions).reduce((a, b) => {
+/******/ if (!satisfy(requiredVersion, b)) return a;
+/******/ return !a || versionLt(a, b) ? b : a;
+/******/ }, 0);
+/******/ return key && versions[key]
+/******/ };
+/******/ var findSingletonVersionKey = (scope, key, eager) => {
+/******/ var versions = eager ? eagerOnly(scope[key]) : scope[key];
+/******/ return Object.keys(versions).reduce((a, b) => {
+/******/ return !a || (!versions[a].loaded && versionLt(a, b)) ? b : a;
+/******/ }, 0);
+/******/ };
+/******/ var getInvalidSingletonVersionMessage = (scope, key, version, requiredVersion) => {
+/******/ return "Unsatisfied version " + version + " from " + (version && scope[key][version].from) + " of shared singleton module " + key + " (required " + rangeToString(requiredVersion) + ")"
+/******/ };
+/******/ var getInvalidVersionMessage = (scope, scopeName, key, requiredVersion, eager) => {
+/******/ var versions = scope[key];
+/******/ return "No satisfying version (" + rangeToString(requiredVersion) + ")" + (eager ? " for eager consumption" : "") + " of shared module " + key + " found in shared scope " + scopeName + ".\n" +
+/******/ "Available versions: " + Object.keys(versions).map((key) => {
+/******/ return key + " from " + versions[key].from;
+/******/ }).join(", ");
+/******/ };
+/******/ var fail = (msg) => {
+/******/ throw new Error(msg);
+/******/ }
+/******/ var failAsNotExist = (scopeName, key) => {
+/******/ return fail("Shared module " + key + " doesn't exist in shared scope " + scopeName);
+/******/ }
+/******/ var warn = /*#__PURE__*/ (msg) => {
+/******/ if (typeof console !== "undefined" && console.warn) console.warn(msg);
+/******/ };
+/******/ var init = (fn) => (function(scopeName, key, eager, c, d) {
+/******/ var promise = __webpack_require__.I(scopeName);
+/******/ if (promise && promise.then && !eager) {
+/******/ return promise.then(fn.bind(fn, scopeName, __webpack_require__.S[scopeName], key, false, c, d));
+/******/ }
+/******/ return fn(scopeName, __webpack_require__.S[scopeName], key, eager, c, d);
+/******/ });
+/******/
+/******/ var useFallback = (scopeName, key, fallback) => {
+/******/ return fallback ? fallback() : failAsNotExist(scopeName, key);
+/******/ }
+/******/ var load = /*#__PURE__*/ init((scopeName, scope, key, eager, fallback) => {
+/******/ if (!exists(scope, key)) return useFallback(scopeName, key, fallback);
+/******/ return get(findLatestVersion(scope, key, eager));
+/******/ });
+/******/ var loadVersion = /*#__PURE__*/ init((scopeName, scope, key, eager, requiredVersion, fallback) => {
+/******/ if (!exists(scope, key)) return useFallback(scopeName, key, fallback);
+/******/ var satisfyingVersion = findSatisfyingVersion(scope, key, requiredVersion, eager);
+/******/ if (satisfyingVersion) return get(satisfyingVersion);
+/******/ warn(getInvalidVersionMessage(scope, scopeName, key, requiredVersion, eager))
+/******/ return get(findLatestVersion(scope, key, eager));
+/******/ });
+/******/ var loadStrictVersion = /*#__PURE__*/ init((scopeName, scope, key, eager, requiredVersion, fallback) => {
+/******/ if (!exists(scope, key)) return useFallback(scopeName, key, fallback);
+/******/ var satisfyingVersion = findSatisfyingVersion(scope, key, requiredVersion, eager);
+/******/ if (satisfyingVersion) return get(satisfyingVersion);
+/******/ if (fallback) return fallback();
+/******/ fail(getInvalidVersionMessage(scope, scopeName, key, requiredVersion, eager));
+/******/ });
+/******/ var loadSingleton = /*#__PURE__*/ init((scopeName, scope, key, eager, fallback) => {
+/******/ if (!exists(scope, key)) return useFallback(scopeName, key, fallback);
+/******/ var version = findSingletonVersionKey(scope, key, eager);
+/******/ return get(scope[key][version]);
+/******/ });
+/******/ var loadSingletonVersion = /*#__PURE__*/ init((scopeName, scope, key, eager, requiredVersion, fallback) => {
+/******/ if (!exists(scope, key)) return useFallback(scopeName, key, fallback);
+/******/ var version = findSingletonVersionKey(scope, key, eager);
+/******/ if (!satisfy(requiredVersion, version)) {
+/******/ warn(getInvalidSingletonVersionMessage(scope, key, version, requiredVersion));
+/******/ }
+/******/ return get(scope[key][version]);
+/******/ });
+/******/ var loadStrictSingletonVersion = /*#__PURE__*/ init((scopeName, scope, key, eager, requiredVersion, fallback) => {
+/******/ if (!exists(scope, key)) return useFallback(scopeName, key, fallback);
+/******/ var version = findSingletonVersionKey(scope, key, eager);
+/******/ if (!satisfy(requiredVersion, version)) {
+/******/ fail(getInvalidSingletonVersionMessage(scope, key, version, requiredVersion));
+/******/ }
+/******/ return get(scope[key][version]);
+/******/ });
+/******/ var installedModules = {};
+/******/ var moduleToHandlerMapping = {
+/******/ "webpack/sharing/consume/default/react-dom/react-dom": () => (loadSingletonVersion("default", "react-dom", true, [1,17,0,2], () => (() => (__webpack_require__(/*! react-dom */ "./node_modules/react-dom/index.js"))))),
+/******/ "webpack/sharing/consume/default/react/react": () => (loadSingletonVersion("default", "react", true, [1,17,0,2], () => (() => (__webpack_require__(/*! react */ "./node_modules/react/index.js")))))
+/******/ };
+/******/ var initialConsumes = ["webpack/sharing/consume/default/react-dom/react-dom","webpack/sharing/consume/default/react/react"];
+/******/ initialConsumes.forEach((id) => {
+/******/ __webpack_require__.m[id] = (module) => {
+/******/ // Handle case when module is used sync
+/******/ installedModules[id] = 0;
+/******/ delete __webpack_require__.c[id];
+/******/ var factory = moduleToHandlerMapping[id]();
+/******/ if(typeof factory !== "function") throw new Error("Shared module is not available for eager consumption: " + id);
+/******/ module.exports = factory();
+/******/ }
+/******/ });
+/******/ // no chunk loading of consumes
+/******/ })();
+/******/
+/******/ /* webpack/runtime/jsonp chunk loading */
+/******/ (() => {
+/******/ // no baseURI
+/******/
+/******/ // object to store loaded and loading chunks
+/******/ // undefined = chunk not loaded, null = chunk preloaded/prefetched
+/******/ // [resolve, reject, Promise] = chunk loading, 0 = chunk loaded
+/******/ var installedChunks = __webpack_require__.hmrS_jsonp = __webpack_require__.hmrS_jsonp || {
+/******/ "service-worker": 0,
+/******/ "webpack_sharing_consume_default_react-dom_react-dom-webpack_sharing_consume_default_react_rea-153fef": 0
+/******/ };
+/******/
+/******/ // no chunk on demand loading
+/******/
+/******/ // no prefetching
+/******/
+/******/ // no preloaded
+/******/
+/******/ var currentUpdatedModulesList;
+/******/ var waitingUpdateResolves = {};
+/******/ function loadUpdateChunk(chunkId, updatedModulesList) {
+/******/ currentUpdatedModulesList = updatedModulesList;
+/******/ return new Promise((resolve, reject) => {
+/******/ waitingUpdateResolves[chunkId] = resolve;
+/******/ // start update chunk loading
+/******/ var url = __webpack_require__.p + __webpack_require__.hu(chunkId);
+/******/ // create error before stack unwound to get useful stacktrace later
+/******/ var error = new Error();
+/******/ var loadingEnded = (event) => {
+/******/ if(waitingUpdateResolves[chunkId]) {
+/******/ waitingUpdateResolves[chunkId] = undefined
+/******/ var errorType = event && (event.type === 'load' ? 'missing' : event.type);
+/******/ var realSrc = event && event.target && event.target.src;
+/******/ error.message = 'Loading hot update chunk ' + chunkId + ' failed.\n(' + errorType + ': ' + realSrc + ')';
+/******/ error.name = 'ChunkLoadError';
+/******/ error.type = errorType;
+/******/ error.request = realSrc;
+/******/ reject(error);
+/******/ }
+/******/ };
+/******/ __webpack_require__.l(url, loadingEnded);
+/******/ });
+/******/ }
+/******/
+/******/ globalThis["webpackHotUpdatesuperset"] = (chunkId, moreModules, runtime) => {
+/******/ for(var moduleId in moreModules) {
+/******/ if(__webpack_require__.o(moreModules, moduleId)) {
+/******/ currentUpdate[moduleId] = moreModules[moduleId];
+/******/ if(currentUpdatedModulesList) currentUpdatedModulesList.push(moduleId);
+/******/ }
+/******/ }
+/******/ if(runtime) currentUpdateRuntime.push(runtime);
+/******/ if(waitingUpdateResolves[chunkId]) {
+/******/ waitingUpdateResolves[chunkId]();
+/******/ waitingUpdateResolves[chunkId] = undefined;
+/******/ }
+/******/ };
+/******/
+/******/ var currentUpdateChunks;
+/******/ var currentUpdate;
+/******/ var currentUpdateRemovedChunks;
+/******/ var currentUpdateRuntime;
+/******/ function applyHandler(options) {
+/******/ if (__webpack_require__.f) delete __webpack_require__.f.jsonpHmr;
+/******/ currentUpdateChunks = undefined;
+/******/ function getAffectedModuleEffects(updateModuleId) {
+/******/ var outdatedModules = [updateModuleId];
+/******/ var outdatedDependencies = {};
+/******/
+/******/ var queue = outdatedModules.map(function (id) {
+/******/ return {
+/******/ chain: [id],
+/******/ id: id
+/******/ };
+/******/ });
+/******/ while (queue.length > 0) {
+/******/ var queueItem = queue.pop();
+/******/ var moduleId = queueItem.id;
+/******/ var chain = queueItem.chain;
+/******/ var module = __webpack_require__.c[moduleId];
+/******/ if (
+/******/ !module ||
+/******/ (module.hot._selfAccepted && !module.hot._selfInvalidated)
+/******/ )
+/******/ continue;
+/******/ if (module.hot._selfDeclined) {
+/******/ return {
+/******/ type: "self-declined",
+/******/ chain: chain,
+/******/ moduleId: moduleId
+/******/ };
+/******/ }
+/******/ if (module.hot._main) {
+/******/ return {
+/******/ type: "unaccepted",
+/******/ chain: chain,
+/******/ moduleId: moduleId
+/******/ };
+/******/ }
+/******/ for (var i = 0; i < module.parents.length; i++) {
+/******/ var parentId = module.parents[i];
+/******/ var parent = __webpack_require__.c[parentId];
+/******/ if (!parent) continue;
+/******/ if (parent.hot._declinedDependencies[moduleId]) {
+/******/ return {
+/******/ type: "declined",
+/******/ chain: chain.concat([parentId]),
+/******/ moduleId: moduleId,
+/******/ parentId: parentId
+/******/ };
+/******/ }
+/******/ if (outdatedModules.indexOf(parentId) !== -1) continue;
+/******/ if (parent.hot._acceptedDependencies[moduleId]) {
+/******/ if (!outdatedDependencies[parentId])
+/******/ outdatedDependencies[parentId] = [];
+/******/ addAllToSet(outdatedDependencies[parentId], [moduleId]);
+/******/ continue;
+/******/ }
+/******/ delete outdatedDependencies[parentId];
+/******/ outdatedModules.push(parentId);
+/******/ queue.push({
+/******/ chain: chain.concat([parentId]),
+/******/ id: parentId
+/******/ });
+/******/ }
+/******/ }
+/******/
+/******/ return {
+/******/ type: "accepted",
+/******/ moduleId: updateModuleId,
+/******/ outdatedModules: outdatedModules,
+/******/ outdatedDependencies: outdatedDependencies
+/******/ };
+/******/ }
+/******/
+/******/ function addAllToSet(a, b) {
+/******/ for (var i = 0; i < b.length; i++) {
+/******/ var item = b[i];
+/******/ if (a.indexOf(item) === -1) a.push(item);
+/******/ }
+/******/ }
+/******/
+/******/ // at begin all updates modules are outdated
+/******/ // the "outdated" status can propagate to parents if they don't accept the children
+/******/ var outdatedDependencies = {};
+/******/ var outdatedModules = [];
+/******/ var appliedUpdate = {};
+/******/
+/******/ var warnUnexpectedRequire = function warnUnexpectedRequire(module) {
+/******/ console.warn(
+/******/ "[HMR] unexpected require(" + module.id + ") to disposed module"
+/******/ );
+/******/ };
+/******/
+/******/ for (var moduleId in currentUpdate) {
+/******/ if (__webpack_require__.o(currentUpdate, moduleId)) {
+/******/ var newModuleFactory = currentUpdate[moduleId];
+/******/ var result = newModuleFactory
+/******/ ? getAffectedModuleEffects(moduleId)
+/******/ : {
+/******/ type: "disposed",
+/******/ moduleId: moduleId
+/******/ };
+/******/ /** @type {Error|false} */
+/******/ var abortError = false;
+/******/ var doApply = false;
+/******/ var doDispose = false;
+/******/ var chainInfo = "";
+/******/ if (result.chain) {
+/******/ chainInfo = "\nUpdate propagation: " + result.chain.join(" -> ");
+/******/ }
+/******/ switch (result.type) {
+/******/ case "self-declined":
+/******/ if (options.onDeclined) options.onDeclined(result);
+/******/ if (!options.ignoreDeclined)
+/******/ abortError = new Error(
+/******/ "Aborted because of self decline: " +
+/******/ result.moduleId +
+/******/ chainInfo
+/******/ );
+/******/ break;
+/******/ case "declined":
+/******/ if (options.onDeclined) options.onDeclined(result);
+/******/ if (!options.ignoreDeclined)
+/******/ abortError = new Error(
+/******/ "Aborted because of declined dependency: " +
+/******/ result.moduleId +
+/******/ " in " +
+/******/ result.parentId +
+/******/ chainInfo
+/******/ );
+/******/ break;
+/******/ case "unaccepted":
+/******/ if (options.onUnaccepted) options.onUnaccepted(result);
+/******/ if (!options.ignoreUnaccepted)
+/******/ abortError = new Error(
+/******/ "Aborted because " + moduleId + " is not accepted" + chainInfo
+/******/ );
+/******/ break;
+/******/ case "accepted":
+/******/ if (options.onAccepted) options.onAccepted(result);
+/******/ doApply = true;
+/******/ break;
+/******/ case "disposed":
+/******/ if (options.onDisposed) options.onDisposed(result);
+/******/ doDispose = true;
+/******/ break;
+/******/ default:
+/******/ throw new Error("Unexception type " + result.type);
+/******/ }
+/******/ if (abortError) {
+/******/ return {
+/******/ error: abortError
+/******/ };
+/******/ }
+/******/ if (doApply) {
+/******/ appliedUpdate[moduleId] = newModuleFactory;
+/******/ addAllToSet(outdatedModules, result.outdatedModules);
+/******/ for (moduleId in result.outdatedDependencies) {
+/******/ if (__webpack_require__.o(result.outdatedDependencies, moduleId)) {
+/******/ if (!outdatedDependencies[moduleId])
+/******/ outdatedDependencies[moduleId] = [];
+/******/ addAllToSet(
+/******/ outdatedDependencies[moduleId],
+/******/ result.outdatedDependencies[moduleId]
+/******/ );
+/******/ }
+/******/ }
+/******/ }
+/******/ if (doDispose) {
+/******/ addAllToSet(outdatedModules, [result.moduleId]);
+/******/ appliedUpdate[moduleId] = warnUnexpectedRequire;
+/******/ }
+/******/ }
+/******/ }
+/******/ currentUpdate = undefined;
+/******/
+/******/ // Store self accepted outdated modules to require them later by the module system
+/******/ var outdatedSelfAcceptedModules = [];
+/******/ for (var j = 0; j < outdatedModules.length; j++) {
+/******/ var outdatedModuleId = outdatedModules[j];
+/******/ var module = __webpack_require__.c[outdatedModuleId];
+/******/ if (
+/******/ module &&
+/******/ (module.hot._selfAccepted || module.hot._main) &&
+/******/ // removed self-accepted modules should not be required
+/******/ appliedUpdate[outdatedModuleId] !== warnUnexpectedRequire &&
+/******/ // when called invalidate self-accepting is not possible
+/******/ !module.hot._selfInvalidated
+/******/ ) {
+/******/ outdatedSelfAcceptedModules.push({
+/******/ module: outdatedModuleId,
+/******/ require: module.hot._requireSelf,
+/******/ errorHandler: module.hot._selfAccepted
+/******/ });
+/******/ }
+/******/ }
+/******/
+/******/ var moduleOutdatedDependencies;
+/******/
+/******/ return {
+/******/ dispose: function () {
+/******/ currentUpdateRemovedChunks.forEach(function (chunkId) {
+/******/ delete installedChunks[chunkId];
+/******/ });
+/******/ currentUpdateRemovedChunks = undefined;
+/******/
+/******/ var idx;
+/******/ var queue = outdatedModules.slice();
+/******/ while (queue.length > 0) {
+/******/ var moduleId = queue.pop();
+/******/ var module = __webpack_require__.c[moduleId];
+/******/ if (!module) continue;
+/******/
+/******/ var data = {};
+/******/
+/******/ // Call dispose handlers
+/******/ var disposeHandlers = module.hot._disposeHandlers;
+/******/ for (j = 0; j < disposeHandlers.length; j++) {
+/******/ disposeHandlers[j].call(null, data);
+/******/ }
+/******/ __webpack_require__.hmrD[moduleId] = data;
+/******/
+/******/ // disable module (this disables requires from this module)
+/******/ module.hot.active = false;
+/******/
+/******/ // remove module from cache
+/******/ delete __webpack_require__.c[moduleId];
+/******/
+/******/ // when disposing there is no need to call dispose handler
+/******/ delete outdatedDependencies[moduleId];
+/******/
+/******/ // remove "parents" references from all children
+/******/ for (j = 0; j < module.children.length; j++) {
+/******/ var child = __webpack_require__.c[module.children[j]];
+/******/ if (!child) continue;
+/******/ idx = child.parents.indexOf(moduleId);
+/******/ if (idx >= 0) {
+/******/ child.parents.splice(idx, 1);
+/******/ }
+/******/ }
+/******/ }
+/******/
+/******/ // remove outdated dependency from module children
+/******/ var dependency;
+/******/ for (var outdatedModuleId in outdatedDependencies) {
+/******/ if (__webpack_require__.o(outdatedDependencies, outdatedModuleId)) {
+/******/ module = __webpack_require__.c[outdatedModuleId];
+/******/ if (module) {
+/******/ moduleOutdatedDependencies =
+/******/ outdatedDependencies[outdatedModuleId];
+/******/ for (j = 0; j < moduleOutdatedDependencies.length; j++) {
+/******/ dependency = moduleOutdatedDependencies[j];
+/******/ idx = module.children.indexOf(dependency);
+/******/ if (idx >= 0) module.children.splice(idx, 1);
+/******/ }
+/******/ }
+/******/ }
+/******/ }
+/******/ },
+/******/ apply: function (reportError) {
+/******/ var acceptPromises = [];
+/******/ // insert new code
+/******/ for (var updateModuleId in appliedUpdate) {
+/******/ if (__webpack_require__.o(appliedUpdate, updateModuleId)) {
+/******/ __webpack_require__.m[updateModuleId] = appliedUpdate[updateModuleId];
+/******/ }
+/******/ }
+/******/
+/******/ // run new runtime modules
+/******/ for (var i = 0; i < currentUpdateRuntime.length; i++) {
+/******/ currentUpdateRuntime[i](__webpack_require__);
+/******/ }
+/******/
+/******/ // call accept handlers
+/******/ for (var outdatedModuleId in outdatedDependencies) {
+/******/ if (__webpack_require__.o(outdatedDependencies, outdatedModuleId)) {
+/******/ var module = __webpack_require__.c[outdatedModuleId];
+/******/ if (module) {
+/******/ moduleOutdatedDependencies =
+/******/ outdatedDependencies[outdatedModuleId];
+/******/ var callbacks = [];
+/******/ var errorHandlers = [];
+/******/ var dependenciesForCallbacks = [];
+/******/ for (var j = 0; j < moduleOutdatedDependencies.length; j++) {
+/******/ var dependency = moduleOutdatedDependencies[j];
+/******/ var acceptCallback =
+/******/ module.hot._acceptedDependencies[dependency];
+/******/ var errorHandler =
+/******/ module.hot._acceptedErrorHandlers[dependency];
+/******/ if (acceptCallback) {
+/******/ if (callbacks.indexOf(acceptCallback) !== -1) continue;
+/******/ callbacks.push(acceptCallback);
+/******/ errorHandlers.push(errorHandler);
+/******/ dependenciesForCallbacks.push(dependency);
+/******/ }
+/******/ }
+/******/ for (var k = 0; k < callbacks.length; k++) {
+/******/ var result;
+/******/ try {
+/******/ result = callbacks[k].call(null, moduleOutdatedDependencies);
+/******/ } catch (err) {
+/******/ if (typeof errorHandlers[k] === "function") {
+/******/ try {
+/******/ errorHandlers[k](err, {
+/******/ moduleId: outdatedModuleId,
+/******/ dependencyId: dependenciesForCallbacks[k]
+/******/ });
+/******/ } catch (err2) {
+/******/ if (options.onErrored) {
+/******/ options.onErrored({
+/******/ type: "accept-error-handler-errored",
+/******/ moduleId: outdatedModuleId,
+/******/ dependencyId: dependenciesForCallbacks[k],
+/******/ error: err2,
+/******/ originalError: err
+/******/ });
+/******/ }
+/******/ if (!options.ignoreErrored) {
+/******/ reportError(err2);
+/******/ reportError(err);
+/******/ }
+/******/ }
+/******/ } else {
+/******/ if (options.onErrored) {
+/******/ options.onErrored({
+/******/ type: "accept-errored",
+/******/ moduleId: outdatedModuleId,
+/******/ dependencyId: dependenciesForCallbacks[k],
+/******/ error: err
+/******/ });
+/******/ }
+/******/ if (!options.ignoreErrored) {
+/******/ reportError(err);
+/******/ }
+/******/ }
+/******/ }
+/******/ if (result && typeof result.then === "function") {
+/******/ acceptPromises.push(result);
+/******/ }
+/******/ }
+/******/ }
+/******/ }
+/******/ }
+/******/
+/******/ var onAccepted = function () {
+/******/ // Load self accepted modules
+/******/ for (var o = 0; o < outdatedSelfAcceptedModules.length; o++) {
+/******/ var item = outdatedSelfAcceptedModules[o];
+/******/ var moduleId = item.module;
+/******/ try {
+/******/ item.require(moduleId);
+/******/ } catch (err) {
+/******/ if (typeof item.errorHandler === "function") {
+/******/ try {
+/******/ item.errorHandler(err, {
+/******/ moduleId: moduleId,
+/******/ module: __webpack_require__.c[moduleId]
+/******/ });
+/******/ } catch (err1) {
+/******/ if (options.onErrored) {
+/******/ options.onErrored({
+/******/ type: "self-accept-error-handler-errored",
+/******/ moduleId: moduleId,
+/******/ error: err1,
+/******/ originalError: err
+/******/ });
+/******/ }
+/******/ if (!options.ignoreErrored) {
+/******/ reportError(err1);
+/******/ reportError(err);
+/******/ }
+/******/ }
+/******/ } else {
+/******/ if (options.onErrored) {
+/******/ options.onErrored({
+/******/ type: "self-accept-errored",
+/******/ moduleId: moduleId,
+/******/ error: err
+/******/ });
+/******/ }
+/******/ if (!options.ignoreErrored) {
+/******/ reportError(err);
+/******/ }
+/******/ }
+/******/ }
+/******/ }
+/******/ };
+/******/
+/******/ return Promise.all(acceptPromises)
+/******/ .then(onAccepted)
+/******/ .then(function () {
+/******/ return outdatedModules;
+/******/ });
+/******/ }
+/******/ };
+/******/ }
+/******/ __webpack_require__.hmrI.jsonp = function (moduleId, applyHandlers) {
+/******/ if (!currentUpdate) {
+/******/ currentUpdate = {};
+/******/ currentUpdateRuntime = [];
+/******/ currentUpdateRemovedChunks = [];
+/******/ applyHandlers.push(applyHandler);
+/******/ }
+/******/ if (!__webpack_require__.o(currentUpdate, moduleId)) {
+/******/ currentUpdate[moduleId] = __webpack_require__.m[moduleId];
+/******/ }
+/******/ };
+/******/ __webpack_require__.hmrC.jsonp = function (
+/******/ chunkIds,
+/******/ removedChunks,
+/******/ removedModules,
+/******/ promises,
+/******/ applyHandlers,
+/******/ updatedModulesList
+/******/ ) {
+/******/ applyHandlers.push(applyHandler);
+/******/ currentUpdateChunks = {};
+/******/ currentUpdateRemovedChunks = removedChunks;
+/******/ currentUpdate = removedModules.reduce(function (obj, key) {
+/******/ obj[key] = false;
+/******/ return obj;
+/******/ }, {});
+/******/ currentUpdateRuntime = [];
+/******/ chunkIds.forEach(function (chunkId) {
+/******/ if (
+/******/ __webpack_require__.o(installedChunks, chunkId) &&
+/******/ installedChunks[chunkId] !== undefined
+/******/ ) {
+/******/ promises.push(loadUpdateChunk(chunkId, updatedModulesList));
+/******/ currentUpdateChunks[chunkId] = true;
+/******/ } else {
+/******/ currentUpdateChunks[chunkId] = false;
+/******/ }
+/******/ });
+/******/ if (__webpack_require__.f) {
+/******/ __webpack_require__.f.jsonpHmr = function (chunkId, promises) {
+/******/ if (
+/******/ currentUpdateChunks &&
+/******/ __webpack_require__.o(currentUpdateChunks, chunkId) &&
+/******/ !currentUpdateChunks[chunkId]
+/******/ ) {
+/******/ promises.push(loadUpdateChunk(chunkId));
+/******/ currentUpdateChunks[chunkId] = true;
+/******/ }
+/******/ };
+/******/ }
+/******/ };
+/******/
+/******/ __webpack_require__.hmrM = () => {
+/******/ if (typeof fetch === "undefined") throw new Error("No browser support: need fetch API");
+/******/ return fetch(__webpack_require__.p + __webpack_require__.hmrF()).then((response) => {
+/******/ if(response.status === 404) return; // no update available
+/******/ if(!response.ok) throw new Error("Failed to fetch update manifest " + response.statusText);
+/******/ return response.json();
+/******/ });
+/******/ };
+/******/
+/******/ __webpack_require__.O.j = (chunkId) => (installedChunks[chunkId] === 0);
+/******/
+/******/ // install a JSONP callback for chunk loading
+/******/ var webpackJsonpCallback = (parentChunkLoadingFunction, data) => {
+/******/ var [chunkIds, moreModules, runtime] = data;
+/******/ // add "moreModules" to the modules object,
+/******/ // then flag all "chunkIds" as loaded and fire callback
+/******/ var moduleId, chunkId, i = 0;
+/******/ if(chunkIds.some((id) => (installedChunks[id] !== 0))) {
+/******/ for(moduleId in moreModules) {
+/******/ if(__webpack_require__.o(moreModules, moduleId)) {
+/******/ __webpack_require__.m[moduleId] = moreModules[moduleId];
+/******/ }
+/******/ }
+/******/ if(runtime) var result = runtime(__webpack_require__);
+/******/ }
+/******/ if(parentChunkLoadingFunction) parentChunkLoadingFunction(data);
+/******/ for(;i < chunkIds.length; i++) {
+/******/ chunkId = chunkIds[i];
+/******/ if(__webpack_require__.o(installedChunks, chunkId) && installedChunks[chunkId]) {
+/******/ installedChunks[chunkId][0]();
+/******/ }
+/******/ installedChunks[chunkId] = 0;
+/******/ }
+/******/ return __webpack_require__.O(result);
+/******/ }
+/******/
+/******/ var chunkLoadingGlobal = globalThis["webpackChunksuperset"] = globalThis["webpackChunksuperset"] || [];
+/******/ chunkLoadingGlobal.forEach(webpackJsonpCallback.bind(null, 0));
+/******/ chunkLoadingGlobal.push = webpackJsonpCallback.bind(null, chunkLoadingGlobal.push.bind(chunkLoadingGlobal));
+/******/ })();
+/******/
+/************************************************************************/
+/******/
+/******/ // module cache are used so entry inlining is disabled
+/******/ // startup
+/******/ // Load entry module and return exports
+/******/ __webpack_require__.O(undefined, ["vendors","vendors-node_modules_rc-component_color-picker_es_index_js-node_modules_rc-component_mutate-o-484854","webpack_sharing_consume_default_react-dom_react-dom-webpack_sharing_consume_default_react_rea-153fef"], () => (__webpack_require__("./node_modules/@pmmmwh/react-refresh-webpack-plugin/client/ReactRefreshEntry.js")))
+/******/ __webpack_require__.O(undefined, ["vendors","vendors-node_modules_rc-component_color-picker_es_index_js-node_modules_rc-component_mutate-o-484854","webpack_sharing_consume_default_react-dom_react-dom-webpack_sharing_consume_default_react_rea-153fef"], () => (__webpack_require__("./node_modules/webpack-dev-server/client/index.js?protocol=ws%3A&hostname=0.0.0.0&port=0&pathname=%2Fws&logging=info&overlay=%7B%22errors%22%3Atrue%2C%22warnings%22%3Afalse%2C%22runtimeErrors%22%3A%22er [...]
+/******/ __webpack_require__.O(undefined, ["vendors","vendors-node_modules_rc-component_color-picker_es_index_js-node_modules_rc-component_mutate-o-484854","webpack_sharing_consume_default_react-dom_react-dom-webpack_sharing_consume_default_react_rea-153fef"], () => (__webpack_require__("./node_modules/webpack/hot/only-dev-server.js")))
+/******/ __webpack_require__.O(undefined, ["vendors","vendors-node_modules_rc-component_color-picker_es_index_js-node_modules_rc-component_mutate-o-484854","webpack_sharing_consume_default_react-dom_react-dom-webpack_sharing_consume_default_react_rea-153fef"], () => (__webpack_require__("./node_modules/@pmmmwh/react-refresh-webpack-plugin/client/ErrorOverlayEntry.js")))
+/******/ var __webpack_exports__ = __webpack_require__.O(undefined, ["vendors","vendors-node_modules_rc-component_color-picker_es_index_js-node_modules_rc-component_mutate-o-484854","webpack_sharing_consume_default_react-dom_react-dom-webpack_sharing_consume_default_react_rea-153fef"], () => (__webpack_require__("./src/service-worker.ts")))
+/******/ __webpack_exports__ = __webpack_require__.O(__webpack_exports__);
+/******/
+/******/ })()
+;
diff --git a/tests/unit_tests/commands/databases/importers/v1/command_test.py b/tests/unit_tests/commands/databases/importers/v1/command_test.py
index 529b43d7343..bb4228af86f 100644
--- a/tests/unit_tests/commands/databases/importers/v1/command_test.py
+++ b/tests/unit_tests/commands/databases/importers/v1/command_test.py
@@ -93,3 +93,43 @@ def test_import_mask_password(
== "postgresql://user:XXXXXXXXXX@localhost:5432/superset"
)
assert database.password == "password" # noqa: S105
+
+
+def test_import_database_with_password_in_config(
+ mocker: MockerFixture,
+ session: Session,
+) -> None:
+ """
+ Test that passwords in the YAML config are used when importing databases.
+ """
+ from superset import db, security_manager
+ from superset.commands.database.importers.v1 import ImportDatabasesCommand
+ from superset.models.core import Database
+
+ mocker.patch("superset.commands.database.importers.v1.utils.add_permissions")
+ mocker.patch.object(security_manager, "can_access", return_value=True)
+
+ configs: dict[str, dict[str, Any]] = {
+ "databases/examples.yaml": {
+ "database_name": "examples_with_password",
+ "sqlalchemy_uri": "postgresql://user:XXXXXXXXXX@localhost:5432/superset",
+ "cache_timeout": None,
+ "expose_in_sqllab": True,
+ "allow_run_async": False,
+ "allow_ctas": False,
+ "allow_cvas": False,
+ "extra": {},
+ "uuid": "b3dc77af-e654-49bb-b321-40f6b559a1ee",
+ "version": "1.0.0",
+ "password": "yaml_password", # Password provided in YAML config
+ "allow_csv_upload": False,
+ },
+ }
+
+ engine = db.session.get_bind()
+ Database.metadata.create_all(engine) # pylint: disable=no-member
+
+ ImportDatabasesCommand._import(configs)
+ uuid = configs["databases/examples.yaml"]["uuid"]
+ database = db.session.query(Database).filter_by(uuid=uuid).one()
+ assert database.password == "yaml_password" # noqa: S105