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

package/es/utils/logger.js

@@ -0,0 +1,91 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+
+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 createLogger from '@alicloud/console-logger-sls';
+var logger = createLogger({
+  project: 'alfa',
+  endpoint: 'cn-wulanchabu.log.aliyuncs.com',
+  // project_xx 的外网域名，在 SLS project 概览里可以找到
+  logstore: 'loader' // 日志落库的地方
+
+});
+var Method;
+
+(function (Method) {
+  Method["log"] = "log";
+  Method["info"] = "info";
+  Method["warn"] = "warn";
+  Method["error"] = "error";
+})(Method || (Method = {}));
+
+var Logger = /*#__PURE__*/function () {
+  function Logger() {
+    var context = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+
+    _classCallCheck(this, Logger);
+
+    this.cache = {};
+    this.context = context;
+  }
+
+  _createClass(Logger, [{
+    key: "setContext",
+    value: function setContext(params) {
+      this.context = _objectSpread(_objectSpread({}, this.context), params);
+    }
+  }, {
+    key: "record",
+    value: function record(params) {
+      this.cache = _objectSpread(_objectSpread({}, this.cache), params);
+    }
+  }, {
+    key: "send",
+    value: function send() {
+      this.track(Method.log, 'METRIC', this.cache);
+      this.cache = {};
+    }
+  }, {
+    key: "info",
+    value: function info(params) {
+      this.track(Method.info, 'INFO', params);
+    }
+  }, {
+    key: "debug",
+    value: function debug(params) {
+      // do not log debug message in production env
+      if (this.context.env === 'prod') return;
+      console.log('DEBUG', this.mergeData(params));
+    }
+  }, {
+    key: "warn",
+    value: function warn(params) {
+      this.track(Method.warn, 'WARN', params);
+    }
+  }, {
+    key: "error",
+    value: function error(params) {
+      this.track(Method.error, 'ERROR', params);
+    }
+  }, {
+    key: "mergeData",
+    value: function mergeData(params) {
+      return _objectSpread(_objectSpread({}, this.context), params);
+    }
+  }, {
+    key: "track",
+    value: function track(method, topic, params) {
+      // do not track during development
+      if (this.context.env === 'local') return;
+      logger[method](topic, this.mergeData(params));
+    }
+  }]);
+
+  return Logger;
+}();
+
+export { Logger as default };

package/lib/base.d.ts

@@ -0,0 +1,24 @@
+import Hook from './utils/hookManager';
+import { IAppConfig } from './types';
+export default class BaseLoader {
+    static create(): BaseLoader;
+    beforeResolve: Hook<IAppConfig>;
+    afterResolve: Hook<IAppConfig>;
+    beforeLoad: Hook<IAppConfig>;
+    afterLoad: Hook<IAppConfig>;
+    config: IAppConfig;
+    constructor();
+    register<P = {}, C = {}>(passInConfig: IAppConfig<P> & C): Promise<IAppConfig<any>>;
+    /**
+     * resolve config and rewrite manifest and url
+     * @param config
+     * @returns
+     */
+    private resolve;
+    /**
+     * loadApp from remote
+     * @param config
+     * @returns
+     */
+    private load;
+}

package/lib/base.js

@@ -0,0 +1,234 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _consoleOsKernal = require("@alicloud/console-os-kernal");
+
+var _utils = require("./utils");
+
+var _hookManager = _interopRequireDefault(require("./utils/hookManager"));
+
+var _logger = _interopRequireDefault(require("./utils/logger"));
+
+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) { (0, _defineProperty2.default)(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; }
+
+var mergeConfig = function mergeConfig(appConfig, logger) {
+  return _objectSpread(_objectSpread({}, appConfig), {}, {
+    env: appConfig.env || (0, _utils.getAlfaEnv)(),
+    logger: appConfig.logger || logger
+  });
+};
+
+var BaseLoader = /*#__PURE__*/function () {
+  function BaseLoader() {
+    (0, _classCallCheck2.default)(this, BaseLoader);
+    this.beforeResolve = new _hookManager.default();
+    this.afterResolve = new _hookManager.default();
+    this.beforeLoad = new _hookManager.default();
+    this.afterLoad = new _hookManager.default();
+  }
+
+  (0, _createClass2.default)(BaseLoader, [{
+    key: "register",
+    value: function () {
+      var _register = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(passInConfig) {
+        var logger, _this$config, name, version, env, chains, flattenHookHandlers, promise;
+
+        return _regenerator.default.wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                logger = new _logger.default();
+
+                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 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2(config) {
+        var manifest, url;
+        return _regenerator.default.wrap(function _callee2$(_context2) {
+          while (1) {
+            switch (_context2.prev = _context2.next) {
+              case 0:
+                manifest = (0, _utils.getManifestFromConfig)(config);
+                url = (0, _utils.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 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee3(config) {
+        var name, container, manifest, props, deps, url, beforeMount, afterMount, beforeUnmount, afterUnmount, beforeUpdate, sandbox, app;
+        return _regenerator.default.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 (0, _consoleOsKernal.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;
+}();
+
+exports.default = BaseLoader;

package/lib/createMicroApp.js

@@ -9,6 +9,7 @@ var _consoleOsKernal = require("@alicloud/console-os-kernal");
 
 var _utils = require("./utils");
 
+// TODO: deprecate in next major version
 var createMicroApp = function createMicroApp(appConfig) {
   var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
   var manifest = (0, _utils.getManifestFromConfig)(appConfig);

package/lib/index.d.ts

@@ -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/lib/index.js

@@ -1,20 +1,57 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+var _exportNames = {
+  createMicroApp: true,
+  getManifest: true,
+  getConfig: true,
+  getLocale: true,
+  BaseLoader: true,
+  Logger: true,
+  createEventBus: true,
+  prefetch: true,
+  IAppConfig: true,
+  IOptions: true,
+  AlfaFactoryOption: true,
+  AlfaConfig: true,
+  IWin: true,
+  AlfaEnvEnum: true,
+  AlfaLogger: true
+};
 Object.defineProperty(exports, "AlfaConfig", {
   enumerable: true,
   get: function get() {
     return _types.AlfaDynamicConfig;
   }
 });
+Object.defineProperty(exports, "AlfaEnvEnum", {
+  enumerable: true,
+  get: function get() {
+    return _types.EnvEnum;
+  }
+});
 Object.defineProperty(exports, "AlfaFactoryOption", {
   enumerable: true,
   get: function get() {
     return _types.AlfaFactoryOption;
   }
 });
+Object.defineProperty(exports, "AlfaLogger", {
+  enumerable: true,
+  get: function get() {
+    return _types.AlfaLogger;
+  }
+});
+Object.defineProperty(exports, "BaseLoader", {
+  enumerable: true,
+  get: function get() {
+    return _base.default;
+  }
+});
 Object.defineProperty(exports, "IAppConfig", {
   enumerable: true,
   get: function get() {
@@ -33,6 +70,12 @@ Object.defineProperty(exports, "IWin", {
     return _types.IWin;
   }
 });
+Object.defineProperty(exports, "Logger", {
+  enumerable: true,
+  get: function get() {
+    return _logger.default;
+  }
+});
 Object.defineProperty(exports, "createEventBus", {
   enumerable: true,
   get: function get() {
@@ -78,6 +121,24 @@ var _getAlfaConfig = require("./utils/getAlfaConfig");
 
 var _getAlfaLocale = require("./utils/getAlfaLocale");
 
+var _base = _interopRequireDefault(require("./base"));
+
+var _logger = _interopRequireDefault(require("./utils/logger"));
+
+var _index = require("./utils/index");
+
+Object.keys(_index).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _index[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _index[key];
+    }
+  });
+});
+
 var _consoleOsKernal = require("@alicloud/console-os-kernal");
 
 var _types = require("./types");

package/lib/types/index.d.ts

@@ -1,5 +1,13 @@
 /// <reference types="react" />
-import { OSApplication, SandBoxOption } from '@alicloud/console-os-kernal';
+import { OSApplication, SandBoxOption, AppInfo } from '@alicloud/console-os-kernal';
+export declare class AlfaLogger<P = any> {
+    record: (params: P) => void;
+    send: () => void;
+    info: (params: P) => void;
+    error: (params: P) => void;
+    warn: (params: P) => void;
+    debug: (params: P) => void;
+}
 declare type Channel = string;
 declare type ChannelLinks = Partial<Record<string, string>>;
 declare type ChannelFeatures = Partial<Record<string, {
@@ -11,11 +19,11 @@ declare type ChannelFeatures = Partial<Record<string, {
         };
     };
 }>>;
-declare type FeatureStatus = Partial<Record<string, string>>;
+declare type FeatureStatus = Partial<Record<string, boolean>>;
 export interface IWin {
     ALIYUN_CONSOLE_I18N_MESSAGE?: Record<string, string>;
-    ALIYUN_CONSOLE_CONFIG?: {
-        fEnv: string;
+    ALIYUN_CONSOLE_CONFIG?: Partial<{
+        fEnv: EnvEnum;
         LOCALE: string;
         CHANNEL: string;
         CHANNEL_LINKS: ChannelLinks;
@@ -25,36 +33,35 @@ export interface IWin {
         portalType: string;
         MAIN_ACCOUNT_PK: string;
         CURRENT_PK: string;
-    };
+    }>;
 }
 export interface IAppManifest {
     scripts: string[];
     styles?: string[];
 }
-export interface IAppConfig<T = any> {
+export interface IAppConfig<P = any> extends IOptions {
     entry?: IAppManifest | string;
     name: string;
+    version?: string;
     container?: HTMLElement | null;
-    props?: Record<string, T>;
-    manifest?: string;
-    logger?: {
-        debug: () => {};
-        error: () => {};
-        warn: () => {};
-        info: () => {};
-    };
+    props?: P;
+    manifest?: AppInfo['manifest'];
+    url?: string;
+    logger?: AlfaLogger;
     deps?: {
         [key: string]: any;
     };
+    app?: OSApplication;
+    env?: EnvEnum;
 }
 export interface IOptions {
-    sandbox?: boolean | SandBoxOption;
-    beforeMount?: (app: OSApplication) => void;
-    afterMount?: (app: OSApplication) => void;
-    beforeUnmount?: (app: OSApplication) => void;
-    afterUnmount?: (app: OSApplication) => void;
-    beforeUpdate?: (app: OSApplication) => void;
-    afterUpdate?: (app: OSApplication) => void;
+    sandbox?: SandBoxOption;
+    beforeMount?: AppInfo['appWillMount'];
+    afterMount?: AppInfo['appDidMount'];
+    beforeUnmount?: AppInfo['appWillUnmount'];
+    afterUnmount?: AppInfo['appDidUnmount'];
+    beforeUpdate?: AppInfo['appWillUpdate'];
+    afterUpdate?: AppInfo['appWillUpdate'];
 }
 export interface AlfaVersion {
     entry: string;
@@ -63,11 +70,15 @@ export declare type LOCALE = 'en_US' | 'zh_CN' | 'zh_TW' | 'zh_HK' | 'ja_JP';
 export declare type AlfaLocaleVersion = {
     [key in LOCALE | 'entry']: string;
 };
-declare type Version = string;
+export declare type Version = string;
+export interface AlfaConfigVersion {
+    [key: string]: string;
+}
 export interface AlfaReleaseConfig {
-    'dist-tags': Record<string, string>;
-    versions: Record<Version, AlfaVersion>;
-    'locales-versions': Record<Version, AlfaLocaleVersion>;
+    'dist-tags'?: Partial<Record<string, string>>;
+    versions?: Record<Version, Partial<AlfaVersion>>;
+    'locales-versions'?: Record<Version, Partial<AlfaLocaleVersion>>;
+    'config-versions'?: Record<Version, Partial<AlfaConfigVersion>>;
 }
 declare type AlfaChannelLinks = Partial<Record<Channel, ChannelLinks>>;
 declare type AlfaChannelFeatures = Partial<Record<Channel, ChannelFeatures>>;
@@ -86,7 +97,10 @@ export interface AlfaDynamicConfig {
     ALL_FEATURE_STATUS: AlfaFeatures;
 }
 export declare type EnvEnum = 'prod' | 'local' | 'pre' | 'daily';
-export interface AlfaFactoryOption extends IOptions {
+/**
+   * @deprecated
+   */
+export interface AlfaFactoryOption extends IAppConfig {
     name: string;
     version?: string;
     env?: EnvEnum;
@@ -94,6 +108,5 @@ export interface AlfaFactoryOption extends IOptions {
     url?: string;
     manifest?: string;
     dependencies?: Record<string, any>;
-    dynamicConfig?: boolean;
 }
 export {};

package/lib/types/index.js

@@ -1,5 +1,16 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
 Object.defineProperty(exports, "__esModule", {
   value: true
-});
+});
+exports.AlfaLogger = void 0;
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var AlfaLogger = function AlfaLogger() {
+  (0, _classCallCheck2.default)(this, AlfaLogger);
+};
+
+exports.AlfaLogger = AlfaLogger;

package/lib/utils/cacheManager.d.ts

@@ -0,0 +1,11 @@
+declare class Cache {
+    static create(): Cache;
+    store: Record<string, unknown>;
+    constructor();
+    getRemote<T = any>(url: string): Promise<T>;
+    get<V = any>(key: string): V;
+    set<V = any>(key: string, value: V): void;
+    clear(): void;
+}
+declare const _default: Cache;
+export default _default;