@alicloud/alfa-core 1.3.0-alpha.1 → 1.3.0-beta.1

package/es/base.js

@@ -0,0 +1,220 @@
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+import { createMicroApp } from '@alicloud/console-os-kernal';
+import { getManifestFromConfig, getURL, getAlfaEnv } from './utils';
+import Hook from './utils/hookManager';
+import Logger from './utils/logger';
+
+var mergeConfig = function mergeConfig(appConfig, logger) {
+  return _objectSpread(_objectSpread({}, appConfig), {}, {
+    env: appConfig.env || getAlfaEnv(),
+    logger: appConfig.logger || logger
+  });
+};
+
+var BaseLoader = /*#__PURE__*/function () {
+  function BaseLoader() {
+    _classCallCheck(this, BaseLoader);
+
+    this.beforeResolve = new Hook();
+    this.afterResolve = new Hook();
+    this.beforeLoad = new Hook();
+    this.afterLoad = new Hook();
+  }
+
+  _createClass(BaseLoader, [{
+    key: "register",
+    value: function () {
+      var _register = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(passInConfig) {
+        var logger, _this$config, name, version, env, chains, flattenHookHandlers, promise;
+
+        return _regeneratorRuntime.wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                logger = new Logger();
+
+                if (passInConfig) {
+                  _context.next = 4;
+                  break;
+                }
+
+                logger.error({
+                  E_MSG: 'cannot find config before start.'
+                });
+                return _context.abrupt("return", Promise.reject(new Error('[alfa-core] cannot find config before start.')));
+
+              case 4:
+                this.config = mergeConfig(passInConfig, logger);
+                _this$config = this.config, name = _this$config.name, version = _this$config.version, env = _this$config.env;
+                logger.setContext({
+                  NAME: name,
+                  VERSION: version,
+                  ENV: env
+                });
+                chains = [];
+
+                flattenHookHandlers = function flattenHookHandlers(handler) {
+                  var fulfilled = handler.fulfilled,
+                      rejected = handler.rejected;
+                  chains.push(fulfilled, rejected);
+                }; // resolve entry from config
+
+
+                this.beforeResolve.handlers.forEach(flattenHookHandlers); // TODO: handle beforeResolve error
+
+                chains.push(this.resolve, undefined); // modify resolved config
+
+                this.afterResolve.handlers.forEach(flattenHookHandlers); // update props before load
+
+                this.beforeLoad.handlers.forEach(flattenHookHandlers); // TODO: handle beforeLoad error
+
+                chains.push(this.load, undefined); // modify context after load
+
+                this.afterLoad.handlers.forEach(flattenHookHandlers);
+                promise = Promise.resolve(this.config);
+
+                while (chains.length) {
+                  promise = promise.then(chains.shift(), chains.shift());
+                }
+
+                return _context.abrupt("return", promise);
+
+              case 18:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee, this);
+      }));
+
+      function register(_x) {
+        return _register.apply(this, arguments);
+      }
+
+      return register;
+    }()
+    /**
+     * resolve config and rewrite manifest and url
+     * @param config
+     * @returns
+     */
+
+  }, {
+    key: "resolve",
+    value: function () {
+      var _resolve = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(config) {
+        var manifest, url;
+        return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+          while (1) {
+            switch (_context2.prev = _context2.next) {
+              case 0:
+                manifest = getManifestFromConfig(config);
+                url = getURL(config);
+
+                if (!(!manifest && !url)) {
+                  _context2.next = 4;
+                  break;
+                }
+
+                throw new Error("No entry or manifest in ".concat(config.name));
+
+              case 4:
+                return _context2.abrupt("return", _objectSpread(_objectSpread({}, config), {}, {
+                  manifest: manifest,
+                  url: url
+                }));
+
+              case 5:
+              case "end":
+                return _context2.stop();
+            }
+          }
+        }, _callee2);
+      }));
+
+      function resolve(_x2) {
+        return _resolve.apply(this, arguments);
+      }
+
+      return resolve;
+    }()
+    /**
+     * loadApp from remote
+     * @param config
+     * @returns
+     */
+
+  }, {
+    key: "load",
+    value: function () {
+      var _load = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3(config) {
+        var name, container, manifest, props, deps, url, beforeMount, afterMount, beforeUnmount, afterUnmount, beforeUpdate, sandbox, app;
+        return _regeneratorRuntime.wrap(function _callee3$(_context3) {
+          while (1) {
+            switch (_context3.prev = _context3.next) {
+              case 0:
+                name = config.name, container = config.container, manifest = config.manifest, props = config.props, deps = config.deps, url = config.url, beforeMount = config.beforeMount, afterMount = config.afterMount, beforeUnmount = config.beforeUnmount, afterUnmount = config.afterUnmount, beforeUpdate = config.beforeUpdate, sandbox = config.sandbox;
+                _context3.next = 3;
+                return createMicroApp({
+                  name: name,
+                  dom: container,
+                  manifest: manifest,
+                  customProps: props,
+                  deps: deps,
+                  url: url,
+                  // logger,
+                  appWillMount: beforeMount,
+                  appDidMount: afterMount,
+                  appWillUnmount: beforeUnmount,
+                  appDidUnmount: afterUnmount,
+                  appWillUpdate: beforeUpdate
+                }, {
+                  sandbox: sandbox // parcel
+
+                });
+
+              case 3:
+                app = _context3.sent;
+                _context3.next = 6;
+                return app.load();
+
+              case 6:
+                return _context3.abrupt("return", _objectSpread(_objectSpread({}, config), {}, {
+                  app: app
+                }));
+
+              case 7:
+              case "end":
+                return _context3.stop();
+            }
+          }
+        }, _callee3);
+      }));
+
+      function load(_x3) {
+        return _load.apply(this, arguments);
+      }
+
+      return load;
+    }()
+  }], [{
+    key: "create",
+    value: // just create instance, will be mounted in loader
+    function create() {
+      return new this();
+    }
+  }]);
+
+  return BaseLoader;
+}();
+
+export { BaseLoader as default };

package/es/createMicroApp.js

@@ -1,5 +1,6 @@
 import { createMicroApp as createConsoleOSMicroApp } from '@alicloud/console-os-kernal';
 import { getManifestFromConfig, getURL } from './utils';
+// TODO: deprecate in next major version
 export var createMicroApp = function createMicroApp(appConfig) {
   var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
   var manifest = getManifestFromConfig(appConfig);

package/es/index.js

@@ -2,5 +2,8 @@ export { createMicroApp } from './createMicroApp';
 export { getManifest } from './utils/getAlfaManifest';
 export { getConfig } from './utils/getAlfaConfig';
 export { getLocale } from './utils/getAlfaLocale';
+export { default as BaseLoader } from './base';
+export { default as Logger } from './utils/logger';
+export * from './utils/index';
 export { createEventBus, prefetch } from '@alicloud/console-os-kernal';
-export { IAppConfig, IOptions, AlfaFactoryOption, AlfaDynamicConfig as AlfaConfig, IWin } from './types';
+export { IAppConfig, IOptions, AlfaFactoryOption, AlfaDynamicConfig as AlfaConfig, IWin, EnvEnum as AlfaEnvEnum, AlfaLogger } from './types';

package/es/types/index.js

@@ -1 +1,4 @@
-export {};
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+export var AlfaLogger = function AlfaLogger() {
+  _classCallCheck(this, AlfaLogger);
+};

package/es/utils/cacheManager.js

@@ -0,0 +1,79 @@
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import axios from 'axios';
+
+var Cache = /*#__PURE__*/function () {
+  function Cache() {
+    _classCallCheck(this, Cache);
+
+    this.store = {};
+  }
+
+  _createClass(Cache, [{
+    key: "getRemote",
+    value: function () {
+      var _getRemote = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(url) {
+        var res, result;
+        return _regeneratorRuntime.wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                if (!this.store[url]) {
+                  _context.next = 2;
+                  break;
+                }
+
+                return _context.abrupt("return", this.store[url]);
+
+              case 2:
+                _context.next = 4;
+                return axios.get(url);
+
+              case 4:
+                res = _context.sent;
+                result = res.data;
+                if (result) this.store[url] = result;
+                return _context.abrupt("return", result);
+
+              case 8:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee, this);
+      }));
+
+      function getRemote(_x) {
+        return _getRemote.apply(this, arguments);
+      }
+
+      return getRemote;
+    }()
+  }, {
+    key: "get",
+    value: function get(key) {
+      return this.store[key];
+    }
+  }, {
+    key: "set",
+    value: function set(key, value) {
+      this.store[key] = value;
+    }
+  }, {
+    key: "clear",
+    value: function clear() {
+      this.store = {};
+    }
+  }], [{
+    key: "create",
+    value: function create() {
+      return new this();
+    }
+  }]);
+
+  return Cache;
+}();
+
+export default Cache.create();

package/es/utils/getAlfaConfig.js

@@ -1,15 +1,7 @@
-import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
 import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
 import _regeneratorRuntime from "@babel/runtime/regenerator";
-
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
-
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
-
-import axios from 'axios';
-import { resolveConfigUrl } from '.';
-var cachedConfig = {};
-var productReg = /@ali\/alfa-cloud-([a-zA-z]*)-(app|widget)-.*/;
+import { getRelease } from './getAlfaRelease';
+import cache from './cacheManager';
 var defaultConfig = {
   ALL_CHANNEL_FEATURE_STATUS: {},
   ALL_CHANNEL_LINKS: {},
@@ -17,60 +9,58 @@ var defaultConfig = {
 };
 /**
  * 获取 Alfa 平台配置的 Config
- * @param option
+ * @param config
  * @returns
  */
 
 export var getConfig = /*#__PURE__*/function () {
-  var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(option) {
-    var matches, configId, resp, configData;
+  var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(config) {
+    var _releaseConfig$distT, _releaseConfig$config, _releaseConfig$config2;
+
+    var releaseConfig, version, configEntry, configData;
     return _regeneratorRuntime.wrap(function _callee$(_context) {
       while (1) {
         switch (_context.prev = _context.next) {
           case 0:
-            matches = option.name.match(productReg);
+            _context.next = 2;
+            return getRelease(config);
 
-            if (matches) {
-              _context.next = 3;
-              break;
-            }
+          case 2:
+            releaseConfig = _context.sent;
+            version = (_releaseConfig$distT = releaseConfig['dist-tags']) === null || _releaseConfig$distT === void 0 ? void 0 : _releaseConfig$distT['config-latest'];
+            configEntry = (_releaseConfig$config = releaseConfig['config-versions']) === null || _releaseConfig$config === void 0 ? void 0 : (_releaseConfig$config2 = _releaseConfig$config[version]) === null || _releaseConfig$config2 === void 0 ? void 0 : _releaseConfig$config2.entry;
+            configData = defaultConfig; // when config is not valid, return empty
 
-            return _context.abrupt("return", defaultConfig);
-
-          case 3:
-            configId = matches[1] || option.name;
-
-            if (cachedConfig[configId]) {
-              _context.next = 15;
+            if (!(!version || configEntry)) {
+              _context.next = 8;
               break;
             }
 
-            _context.prev = 5;
-            _context.next = 8;
-            return axios.get(resolveConfigUrl(_objectSpread(_objectSpread({}, option), {}, {
-              name: configId
-            })));
+            return _context.abrupt("return", configData);
 
           case 8:
-            resp = _context.sent;
-            configData = resp.data;
-            cachedConfig[configId] = configData;
-            _context.next = 15;
-            break;
+            _context.prev = 8;
+            _context.next = 11;
+            return cache.getRemote(configEntry);
 
-          case 13:
-            _context.prev = 13;
-            _context.t0 = _context["catch"](5);
+          case 11:
+            configData = _context.sent;
+            _context.next = 16;
+            break;
 
-          case 15:
-            return _context.abrupt("return", cachedConfig[configId] || defaultConfig);
+          case 14:
+            _context.prev = 14;
+            _context.t0 = _context["catch"](8);
 
           case 16:
+            return _context.abrupt("return", configData);
+
+          case 17:
           case "end":
             return _context.stop();
         }
       }
-    }, _callee, null, [[5, 13]]);
+    }, _callee, null, [[8, 14]]);
   }));
 
   return function getConfig(_x) {

package/es/utils/getAlfaLocale.js

@@ -1,53 +1,63 @@
 import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
 import _regeneratorRuntime from "@babel/runtime/regenerator";
-import axios from 'axios';
-import { resolveReleaseUrl, getAlfaLocale } from './index';
+import { getAlfaLocale } from './index';
+import { getRelease } from './getAlfaRelease';
+import cache from './cacheManager';
+/**
+ * 获取国际化文案
+ * @param config
+ * @returns
+ */
+
 export var getLocale = /*#__PURE__*/function () {
-  var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(option) {
+  var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(config) {
     var _releaseConfig$distT, _releaseConfig$locale, _releaseConfig$locale2;
 
-    var resp, locale, releaseConfig, version, localeEntry, messages, res;
+    var releaseConfig, locale, version, localeEntry, messages;
     return _regeneratorRuntime.wrap(function _callee$(_context) {
       while (1) {
         switch (_context.prev = _context.next) {
           case 0:
             _context.next = 2;
-            return axios.get(resolveReleaseUrl(option));
+            return getRelease(config);
 
           case 2:
-            resp = _context.sent;
+            releaseConfig = _context.sent;
             locale = getAlfaLocale();
-            releaseConfig = resp.data;
             version = (_releaseConfig$distT = releaseConfig['dist-tags']) === null || _releaseConfig$distT === void 0 ? void 0 : _releaseConfig$distT['locales-latest'];
             localeEntry = (_releaseConfig$locale = releaseConfig['locales-versions']) === null || _releaseConfig$locale === void 0 ? void 0 : (_releaseConfig$locale2 = _releaseConfig$locale[version]) === null || _releaseConfig$locale2 === void 0 ? void 0 : _releaseConfig$locale2[locale];
+            messages = {};
 
-            if (!localeEntry) {// throw new Error(`${option.name} ${locale} entry is not found, please check you release.`);
+            if (localeEntry) {
+              _context.next = 9;
+              break;
             }
 
-            messages = {};
+            return _context.abrupt("return", messages);
+
+          case 9:
             _context.prev = 9;
             _context.next = 12;
-            return axios.get(localeEntry);
+            return cache.getRemote(localeEntry);
 
           case 12:
-            res = _context.sent;
-            messages = res.data;
-            _context.next = 18;
+            messages = _context.sent;
+            _context.next = 17;
             break;
 
-          case 16:
-            _context.prev = 16;
+          case 15:
+            _context.prev = 15;
             _context.t0 = _context["catch"](9);
 
-          case 18:
+          case 17:
             return _context.abrupt("return", messages);
 
-          case 19:
+          case 18:
           case "end":
             return _context.stop();
         }
       }
-    }, _callee, null, [[9, 16]]);
+    }, _callee, null, [[9, 15]]);
   }));
 
   return function getLocale(_x) {

package/es/utils/getAlfaManifest.js

@@ -1,32 +1,31 @@
 import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
 import _regeneratorRuntime from "@babel/runtime/regenerator";
-import axios from 'axios';
-import { resolveReleaseUrl } from '.';
+import { getRelease } from './getAlfaRelease';
 export var getManifest = /*#__PURE__*/function () {
-  var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(option) {
+  var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(config) {
     var _releaseConfig$distT2;
 
-    var resp, releaseConfig, version, _releaseConfig$distT, configByVersion;
+    var name, version, releaseConfig, _releaseConfig$distT, configByVersion;
 
     return _regeneratorRuntime.wrap(function _callee$(_context) {
       while (1) {
         switch (_context.prev = _context.next) {
           case 0:
-            _context.next = 2;
-            return axios.get(resolveReleaseUrl(option));
+            name = config.name;
+            version = config.version;
+            _context.next = 4;
+            return getRelease(config);
 
-          case 2:
-            resp = _context.sent;
-            releaseConfig = resp.data;
-            version = option.version;
+          case 4:
+            releaseConfig = _context.sent;
 
-            if (!option.version) {
+            if (!config.version) {
               version = (_releaseConfig$distT = releaseConfig['dist-tags']) === null || _releaseConfig$distT === void 0 ? void 0 : _releaseConfig$distT.latest;
             } // if version is in dist-tags, return value
 
 
-            if ((_releaseConfig$distT2 = releaseConfig['dist-tags']) !== null && _releaseConfig$distT2 !== void 0 && _releaseConfig$distT2[option.version]) {
-              version = releaseConfig['dist-tags'][option.version];
+            if ((_releaseConfig$distT2 = releaseConfig['dist-tags']) !== null && _releaseConfig$distT2 !== void 0 && _releaseConfig$distT2[config.version]) {
+              version = releaseConfig['dist-tags'][config.version];
             }
 
             configByVersion = releaseConfig.versions[version];
@@ -36,7 +35,7 @@ export var getManifest = /*#__PURE__*/function () {
               break;
             }
 
-            throw new Error("".concat(option.name, "@").concat(version, " is not found, please check you release."));
+            throw new Error("".concat(name, "@").concat(version, " is not found, please check you release."));
 
           case 10:
             return _context.abrupt("return", releaseConfig.versions[version].entry);

package/es/utils/getAlfaRelease.js

@@ -0,0 +1,37 @@
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import { resolveReleaseUrl } from '.';
+import cache from './cacheManager';
+export var getRelease = /*#__PURE__*/function () {
+  var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(config) {
+    var name, releaseConfig;
+    return _regeneratorRuntime.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            name = config.name;
+            _context.prev = 1;
+            _context.next = 4;
+            return cache.getRemote(resolveReleaseUrl(config));
+
+          case 4:
+            releaseConfig = _context.sent;
+            return _context.abrupt("return", releaseConfig);
+
+          case 8:
+            _context.prev = 8;
+            _context.t0 = _context["catch"](1);
+            throw new Error("".concat(name, " releaseConfig loading failed, please try again or connect developers."));
+
+          case 11:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee, null, [[1, 8]]);
+  }));
+
+  return function getRelease(_x) {
+    return _ref.apply(this, arguments);
+  };
+}();

package/es/utils/hookManager.js

@@ -0,0 +1,33 @@
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+
+var Hook = /*#__PURE__*/function () {
+  function Hook() {
+    _classCallCheck(this, Hook);
+
+    this.handlers = [];
+  }
+
+  _createClass(Hook, [{
+    key: "use",
+    value: function use(fulfilled) {
+      var _this = this;
+
+      var rejected = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : undefined;
+      var handler = {
+        fulfilled: fulfilled,
+        rejected: rejected
+      };
+      this.handlers.push(handler);
+      return function () {
+        _this.handlers = _this.handlers.filter(function (h) {
+          return h !== handler;
+        });
+      };
+    }
+  }]);
+
+  return Hook;
+}();
+
+export { Hook as default };

package/es/utils/index.js

@@ -21,7 +21,7 @@ export var getAlfaEnv = function getAlfaEnv() {
 export var getAlfaLocale = function getAlfaLocale() {
   var _window2, _window2$ALIYUN_CONSO;
 
-  var locale = (_window2 = window) === null || _window2 === void 0 ? void 0 : (_window2$ALIYUN_CONSO = _window2.ALIYUN_CONSOLE_CONFIG) === null || _window2$ALIYUN_CONSO === void 0 ? void 0 : _window2$ALIYUN_CONSO.LOCALE.replace('-', '_');
+  var locale = (((_window2 = window) === null || _window2 === void 0 ? void 0 : (_window2$ALIYUN_CONSO = _window2.ALIYUN_CONSOLE_CONFIG) === null || _window2$ALIYUN_CONSO === void 0 ? void 0 : _window2$ALIYUN_CONSO.LOCALE) || '').replace('-', '_');
   if (['zh_CN', 'en_US', 'ja_JP', 'zh_TW', 'zh-HK'].includes(locale)) return locale;
   return 'en_US';
 };
@@ -85,11 +85,15 @@ export var getConfigUrl = function getConfigUrl(name, env) {
 
   return undefined;
 };
-export var resolveReleaseUrl = function resolveReleaseUrl(option) {
-  return getReleaseUrl(option.name, option.env || getAlfaEnv());
+export var resolveReleaseUrl = function resolveReleaseUrl(config) {
+  var name = config.name,
+      env = config.env;
+  return getReleaseUrl(name, env || getAlfaEnv());
 };
-export var resolveConfigUrl = function resolveConfigUrl(option) {
-  return getConfigUrl(option.name, option.env || getAlfaEnv());
+export var resolveConfigUrl = function resolveConfigUrl(config) {
+  var name = config.name,
+      env = config.env;
+  return getConfigUrl(name, env || getAlfaEnv());
 };
 export var getURL = function getURL(appConfig) {
   var entry = appConfig.entry;