@module-federation/devtools 2.7.0 → 2.8.0

package/dist/types/utils/chrome/index.js

@@ -0,0 +1,321 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+var chrome_exports = {};
+__export(chrome_exports, {
+  TabInfo: () => TabInfo,
+  getCurrentTabId: () => getCurrentTabId,
+  getGlobalModuleInfo: () => getGlobalModuleInfo,
+  getInspectWindowTabId: () => getInspectWindowTabId,
+  getScope: () => getScope,
+  getTabs: () => getTabs,
+  getUrl: () => getUrl,
+  injectPostMessage: () => injectPostMessage,
+  injectScript: () => injectScript,
+  injectToast: () => injectToast,
+  normalizeModuleInfoPayload: () => normalizeModuleInfoPayload,
+  refreshModuleInfo: () => refreshModuleInfo,
+  setChromeStorage: () => setChromeStorage,
+  setTargetTab: () => setTargetTab,
+  syncActiveTab: () => syncActiveTab
+});
+module.exports = __toCommonJS(chrome_exports);
+var import_constant = require("../../template/constant");
+var import_sdk2 = require("../sdk");
+var import_safe_post_message = require("./safe-post-message");
+__reExport(chrome_exports, require("./storage"), module.exports);
+const isModuleInfoRecord = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
+const isModuleInfoSyncMessage = (value) => isModuleInfoRecord(value) && ("moduleInfo" in value || "updateModule" in value || "share" in value);
+const normalizeModuleInfoPayload = (moduleInfo) => {
+  const sanitized = (0, import_safe_post_message.sanitizePostMessagePayload)(moduleInfo);
+  if (!isModuleInfoRecord(sanitized)) {
+    return {};
+  }
+  return Object.entries(sanitized).reduce(
+    (moduleMap, [moduleId, snapshot]) => {
+      if (moduleId === "extendInfos" || isModuleInfoRecord(snapshot)) {
+        moduleMap[moduleId] = snapshot;
+      }
+      return moduleMap;
+    },
+    {}
+  );
+};
+const sleep = (num) => {
+  return new Promise((resolve) => {
+    setTimeout(() => {
+      resolve();
+    }, num);
+  });
+};
+const injectPostMessage = (postMessageUrl) => {
+  const script = document.createElement("script");
+  script.src = postMessageUrl;
+  document.getElementsByTagName("head")[0].appendChild(script);
+};
+const TabInfo = {
+  currentTabId: 0
+};
+const setTargetTab = (tab) => {
+  if (!tab || typeof tab.id !== "number") {
+    return;
+  }
+  window.targetTab = tab;
+  TabInfo.currentTabId = tab.id;
+};
+const syncActiveTab = (tabId) => __async(void 0, null, function* () {
+  try {
+    if (typeof tabId === "number") {
+      const tab = yield chrome.tabs.get(tabId);
+      setTargetTab(tab);
+      return tab;
+    }
+    const tabs = yield getTabs({
+      active: true,
+      lastFocusedWindow: true
+    });
+    const activeTab = Array.isArray(tabs) ? tabs[0] : void 0;
+    setTargetTab(activeTab);
+    return activeTab;
+  } catch (error) {
+    console.warn("[Module Federation Devtools] syncActiveTab failed", error);
+    return void 0;
+  }
+});
+function getCurrentTabId() {
+  return TabInfo.currentTabId;
+}
+function getInspectWindowTabId() {
+  return new Promise((resolve, reject) => {
+    var _a, _b;
+    if ((_a = chrome == null ? void 0 : chrome.devtools) == null ? void 0 : _a.inspectedWindow) {
+      if (chrome.isDevMode) {
+        resolve(0);
+      }
+      chrome.devtools.inspectedWindow.eval(
+        'typeof window.__FEDERATION__ !== "undefined" || typeof window.__VMOK__ !== "undefined"',
+        function(info, error) {
+          const { tabId } = chrome.devtools.inspectedWindow;
+          getTabs().then((tabs) => {
+            const target = Array.isArray(tabs) ? tabs.find((tab) => tab.id === tabId) : void 0;
+            setTargetTab(target);
+          });
+          console.log(
+            "chrome.devtools.inspectedWindow.tabId",
+            chrome.devtools.inspectedWindow.tabId
+          );
+          TabInfo.currentTabId = tabId;
+          resolve(tabId);
+          if (error) {
+            reject(error);
+          }
+        }
+      );
+    } else {
+      if ((_b = window.targetTab) == null ? void 0 : _b.id) {
+        const tabId = window.targetTab.id;
+        TabInfo.currentTabId = tabId;
+        resolve(tabId);
+      } else {
+        throw Error(`can't get active tab`);
+      }
+    }
+  });
+}
+const refreshModuleInfo = () => __async(void 0, null, function* () {
+  var _a;
+  if (typeof window !== "undefined" && ((_a = window.__FEDERATION__) == null ? void 0 : _a.moduleInfo)) {
+  }
+  yield sleep(50);
+  const postMessageStartUrl = getUrl("post-message-start.js");
+  yield injectScript(injectPostMessage, false, postMessageStartUrl);
+});
+const getGlobalModuleInfo = (callback) => __async(void 0, null, function* () {
+  var _a, _b;
+  if (typeof window !== "undefined" && ((_a = window.__FEDERATION__) == null ? void 0 : _a.moduleInfo)) {
+    callback(normalizeModuleInfoPayload((_b = window.__FEDERATION__) == null ? void 0 : _b.moduleInfo));
+  }
+  yield sleep(300);
+  const listener = (message) => {
+    const { data } = message;
+    if (!isModuleInfoSyncMessage(data) || (data == null ? void 0 : data.appInfos)) {
+      return;
+    }
+    if (!(window == null ? void 0 : window.__FEDERATION__)) {
+      (0, import_sdk2.definePropertyGlobalVal)(window, "__FEDERATION__", {});
+      (0, import_sdk2.definePropertyGlobalVal)(window, "__VMOK__", window.__FEDERATION__);
+    }
+    window.__FEDERATION__.originModuleInfo = "moduleInfo" in data ? normalizeModuleInfoPayload(data.moduleInfo) : normalizeModuleInfoPayload(
+      window.__FEDERATION__.originModuleInfo || window.__FEDERATION__.moduleInfo
+    );
+    const updateModule = data.updateModule;
+    if (isModuleInfoRecord(updateModule) && typeof updateModule.name === "string") {
+      const updateModuleName = updateModule.name;
+      const moduleIds = Object.keys(window.__FEDERATION__.originModuleInfo);
+      const shouldUpdate = !moduleIds.some(
+        (id) => id.includes(updateModuleName)
+      );
+      if (shouldUpdate) {
+        const destination = typeof updateModule.entry === "string" ? updateModule.entry : typeof updateModule.version === "string" ? updateModule.version : void 0;
+        if (destination) {
+          window.__FEDERATION__.originModuleInfo[`${updateModuleName}:${destination}`] = {
+            remoteEntry: destination,
+            version: destination
+          };
+        }
+      }
+    }
+    if (data == null ? void 0 : data.share) {
+      window.__FEDERATION__.__SHARE__ = (0, import_safe_post_message.sanitizePostMessagePayload)(
+        data.share
+      );
+    }
+    window.__FEDERATION__.moduleInfo = normalizeModuleInfoPayload(
+      window.__FEDERATION__.originModuleInfo
+    );
+    console.log("getGlobalModuleInfo window", window.__FEDERATION__);
+    callback(window.__FEDERATION__.moduleInfo);
+  };
+  chrome.runtime.onMessage.addListener(listener);
+  yield refreshModuleInfo();
+  return () => chrome.runtime.onMessage.removeListener(listener);
+});
+const getTabs = (queryOptions = {}) => chrome.tabs.query(queryOptions);
+const getScope = () => __async(void 0, null, function* () {
+  const activeTab = window.targetTab;
+  const tabId = activeTab == null ? void 0 : activeTab.id;
+  return tabId ? String(tabId) : "noScope";
+});
+const injectScript = (excuteScript, world = false, ...args) => __async(void 0, null, function* () {
+  yield getInspectWindowTabId();
+  return chrome.scripting.executeScript({
+    target: {
+      tabId: getCurrentTabId()
+    },
+    func: excuteScript,
+    world: world ? "MAIN" : "ISOLATED",
+    args
+  }).then((results) => {
+    var _a;
+    console.log("InjectScript success, excuteScript:", args);
+    if (Array.isArray(results) && results.length) {
+      return (_a = results[0]) == null ? void 0 : _a.result;
+    }
+    return void 0;
+  }).catch((e) => {
+    console.log(e, "InjectScript fail, excuteScript:", args);
+    return void 0;
+  });
+});
+const getUrl = (file) => {
+  try {
+    const pathSet = chrome.runtime.getURL(file).split("/");
+    const fileName = pathSet.pop();
+    pathSet.push("static", "js", fileName);
+    return pathSet.join("/");
+  } catch (e) {
+    return "";
+  }
+};
+const injectToast = (toastUtilUrl, e2eFlag) => {
+  const ele = document.querySelector(`[data-e2e=${e2eFlag}]`);
+  if (ele) {
+    return;
+  }
+  const scriptToast = document.createElement("script");
+  scriptToast.src = toastUtilUrl;
+  scriptToast.dataset.e2e = e2eFlag;
+  document.getElementsByTagName("head")[0].appendChild(scriptToast);
+};
+const setChromeStorage = (formData) => {
+  getScope().then((scope) => __async(void 0, null, function* () {
+    const data = yield chrome.storage.sync.get("FormID");
+    const storeData = data[import_constant.FormID];
+    const scopes = Object.keys(storeData || {});
+    let filterOutDatedData = storeData || {};
+    const { length } = scopes;
+    if (length >= 10) {
+      filterOutDatedData = scopes.slice(0, length - 3).reduce((memo, cur) => {
+        memo[cur] = storeData[cur];
+        return memo;
+      }, {});
+    }
+    const existRules = storeData == null ? void 0 : storeData[scope];
+    chrome.storage.sync.set({
+      [import_constant.FormID]: __spreadProps(__spreadValues({}, filterOutDatedData), {
+        [scope]: __spreadValues(__spreadValues({}, existRules), formData)
+      })
+    });
+  }));
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TabInfo,
+  getCurrentTabId,
+  getGlobalModuleInfo,
+  getInspectWindowTabId,
+  getScope,
+  getTabs,
+  getUrl,
+  injectPostMessage,
+  injectScript,
+  injectToast,
+  normalizeModuleInfoPayload,
+  refreshModuleInfo,
+  setChromeStorage,
+  setTargetTab,
+  syncActiveTab,
+  ...require("./storage")
+});

package/dist/types/utils/chrome/messages.js

@@ -0,0 +1,39 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var messages_exports = {};
+__export(messages_exports, {
+  MESSAGE_ACTIVE_TAB_CHANGED: () => MESSAGE_ACTIVE_TAB_CHANGED,
+  MESSAGE_OBSERVABILITY_DEVTOOLS_EVENT: () => MESSAGE_OBSERVABILITY_DEVTOOLS_EVENT,
+  MESSAGE_OPEN_SIDE_PANEL: () => MESSAGE_OPEN_SIDE_PANEL,
+  OBSERVABILITY_DEVTOOLS_SOURCE: () => OBSERVABILITY_DEVTOOLS_SOURCE,
+  OBSERVABILITY_DEVTOOLS_STORAGE_KEY: () => OBSERVABILITY_DEVTOOLS_STORAGE_KEY
+});
+module.exports = __toCommonJS(messages_exports);
+const MESSAGE_OPEN_SIDE_PANEL = "mf-devtools/open-side-panel";
+const MESSAGE_ACTIVE_TAB_CHANGED = "mf-devtools/active-tab-changed";
+const MESSAGE_OBSERVABILITY_DEVTOOLS_EVENT = "mf-devtools/observability-event";
+const OBSERVABILITY_DEVTOOLS_SOURCE = "module-federation/observability";
+const OBSERVABILITY_DEVTOOLS_STORAGE_KEY = "__MF_DEVTOOLS_OBSERVABILITY_CONFIG__";
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MESSAGE_ACTIVE_TAB_CHANGED,
+  MESSAGE_OBSERVABILITY_DEVTOOLS_EVENT,
+  MESSAGE_OPEN_SIDE_PANEL,
+  OBSERVABILITY_DEVTOOLS_SOURCE,
+  OBSERVABILITY_DEVTOOLS_STORAGE_KEY
+});

package/dist/types/utils/chrome/observability-plugin.js

@@ -0,0 +1,85 @@
+var import_chrome_devtool = require("@module-federation/observability-plugin/chrome-devtool");
+var import_messages = require("./messages");
+var import_observability_shared = require("./observability-shared");
+const DEVTOOLS_PLUGIN_NAME = "observability-plugin:chrome-extension";
+const LEGACY_DEVTOOLS_PLUGIN_NAME = "observability-plugin-devtools";
+const getFederationWindow = () => window;
+const safeReadStoredConfig = () => {
+  var _a;
+  try {
+    const raw = (_a = window.localStorage) == null ? void 0 : _a.getItem(
+      import_messages.OBSERVABILITY_DEVTOOLS_STORAGE_KEY
+    );
+    if (!raw) {
+      return void 0;
+    }
+    return (0, import_observability_shared.normalizeObservabilityDevtoolsConfig)(JSON.parse(raw));
+  } catch (e) {
+    return void 0;
+  }
+};
+const defineWritableGlobal = (key, value) => {
+  const targetWindow = getFederationWindow();
+  try {
+    Object.defineProperty(targetWindow, key, {
+      value,
+      configurable: true,
+      writable: true
+    });
+  } catch (e) {
+    targetWindow[key] = value;
+  }
+};
+const ensureFederationGlobal = () => {
+  var _a;
+  const targetWindow = getFederationWindow();
+  const federation = targetWindow.__FEDERATION__ || targetWindow.__VMOK__ || {};
+  if (!targetWindow.__FEDERATION__) {
+    defineWritableGlobal("__FEDERATION__", federation);
+  }
+  if (!targetWindow.__VMOK__) {
+    defineWritableGlobal("__VMOK__", targetWindow.__FEDERATION__);
+  }
+  if (!((_a = targetWindow.__FEDERATION__) == null ? void 0 : _a.__GLOBAL_PLUGIN__)) {
+    targetWindow.__FEDERATION__ = targetWindow.__FEDERATION__ || federation;
+    targetWindow.__FEDERATION__.__GLOBAL_PLUGIN__ = [];
+  }
+  return targetWindow.__FEDERATION__;
+};
+const notifyInstalled = (status, reason, config) => {
+  try {
+    window.postMessage(
+      {
+        schemaVersion: 1,
+        source: import_messages.OBSERVABILITY_DEVTOOLS_SOURCE,
+        kind: status,
+        reason,
+        config,
+        createdAt: Date.now()
+      },
+      "*"
+    );
+  } catch (e) {
+  }
+};
+const install = () => {
+  const config = safeReadStoredConfig();
+  if (!(config == null ? void 0 : config.enabled)) {
+    return;
+  }
+  const federation = ensureFederationGlobal();
+  const globalPlugins = (federation == null ? void 0 : federation.__GLOBAL_PLUGIN__) || [];
+  if (globalPlugins.some(
+    (plugin2) => (plugin2 == null ? void 0 : plugin2.name) === DEVTOOLS_PLUGIN_NAME || (plugin2 == null ? void 0 : plugin2.name) === LEGACY_DEVTOOLS_PLUGIN_NAME
+  )) {
+    notifyInstalled("skipped", "already-installed", config);
+    return;
+  }
+  const plugin = (0, import_chrome_devtool.ChromeObservabilityPlugin)(
+    (0, import_observability_shared.createObservabilityPluginOptions)(config)
+  );
+  globalPlugins.push(plugin);
+  federation.__GLOBAL_PLUGIN__ = globalPlugins;
+  notifyInstalled("installed", void 0, config);
+};
+install();

package/dist/types/utils/chrome/observability-shared.js

@@ -0,0 +1,125 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var observability_shared_exports = {};
+__export(observability_shared_exports, {
+  CHROME_OBSERVABILITY_SCOPE: () => CHROME_OBSERVABILITY_SCOPE,
+  DEFAULT_OBSERVABILITY_DEVTOOLS_CONFIG: () => DEFAULT_OBSERVABILITY_DEVTOOLS_CONFIG,
+  createObservabilityPluginOptions: () => createObservabilityPluginOptions,
+  normalizeObservabilityDevtoolsConfig: () => normalizeObservabilityDevtoolsConfig
+});
+module.exports = __toCommonJS(observability_shared_exports);
+var import_messages = require("./messages");
+const CHROME_OBSERVABILITY_SCOPE = "chrome_extension";
+const MIN_EVENTS = 10;
+const MAX_EVENTS = 1e3;
+const DEFAULT_OBSERVABILITY_DEVTOOLS_CONFIG = {
+  enabled: true,
+  level: "verbose",
+  maxEvents: 300,
+  console: true,
+  browser: {
+    enabled: true,
+    scope: CHROME_OBSERVABILITY_SCOPE,
+    mode: "development"
+  },
+  trace: {
+    printStart: true
+  },
+  react: {
+    injectLoadedCallback: false,
+    remoteIds: []
+  }
+};
+const isObject = (value) => typeof value === "object" && value !== null;
+const normalizeBoolean = (value, fallback) => typeof value === "boolean" ? value : fallback;
+const normalizeLevel = (value) => value === "error" || value === "summary" || value === "verbose" ? value : DEFAULT_OBSERVABILITY_DEVTOOLS_CONFIG.level;
+const normalizeMode = (value) => value === "production" || value === "development" ? value : DEFAULT_OBSERVABILITY_DEVTOOLS_CONFIG.browser.mode;
+const normalizeMaxEvents = (value) => {
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed)) {
+    return DEFAULT_OBSERVABILITY_DEVTOOLS_CONFIG.maxEvents;
+  }
+  return Math.max(MIN_EVENTS, Math.min(MAX_EVENTS, Math.floor(parsed)));
+};
+const normalizeScope = (value) => {
+  if (typeof value !== "string") {
+    return CHROME_OBSERVABILITY_SCOPE;
+  }
+  const trimmed = value.trim().replace(/[^\w:@.-]+/g, "-");
+  return trimmed || CHROME_OBSERVABILITY_SCOPE;
+};
+const normalizeObservabilityDevtoolsConfig = (value) => {
+  const source = isObject(value) ? value : {};
+  const browser = isObject(source.browser) ? source.browser : {};
+  const trace = isObject(source.trace) ? source.trace : {};
+  return {
+    enabled: normalizeBoolean(
+      source.enabled,
+      DEFAULT_OBSERVABILITY_DEVTOOLS_CONFIG.enabled
+    ),
+    level: normalizeLevel(source.level),
+    maxEvents: normalizeMaxEvents(source.maxEvents),
+    console: normalizeBoolean(
+      source.console,
+      DEFAULT_OBSERVABILITY_DEVTOOLS_CONFIG.console
+    ),
+    browser: {
+      enabled: normalizeBoolean(
+        browser.enabled,
+        DEFAULT_OBSERVABILITY_DEVTOOLS_CONFIG.browser.enabled
+      ),
+      scope: normalizeScope(browser.scope),
+      mode: normalizeMode(browser.mode)
+    },
+    trace: {
+      printStart: normalizeBoolean(
+        trace.printStart,
+        DEFAULT_OBSERVABILITY_DEVTOOLS_CONFIG.trace.printStart
+      )
+    },
+    react: {
+      injectLoadedCallback: false,
+      remoteIds: []
+    }
+  };
+};
+const createObservabilityPluginOptions = (config) => ({
+  enabled: config.enabled,
+  level: config.level,
+  maxEvents: config.maxEvents,
+  console: config.console,
+  browser: {
+    enabled: config.browser.enabled,
+    scope: config.browser.scope,
+    mode: config.browser.mode
+  },
+  trace: {
+    printStart: config.trace.printStart
+  },
+  devtools: {
+    enabled: true,
+    source: import_messages.OBSERVABILITY_DEVTOOLS_SOURCE
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CHROME_OBSERVABILITY_SCOPE,
+  DEFAULT_OBSERVABILITY_DEVTOOLS_CONFIG,
+  createObservabilityPluginOptions,
+  normalizeObservabilityDevtoolsConfig
+});