@cuipengyu5/bling-renderer-core 0.0.1

package/es/utils/data-helper.js

@@ -0,0 +1,300 @@
+import _extends from "@babel/runtime/helpers/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/objectWithoutPropertiesLoose";
+var _excluded = ["uri", "url", "method", "headers", "params"],
+  _excluded2 = ["headers"];
+/* eslint-disable no-console */
+/* eslint-disable max-len */
+/* eslint-disable object-curly-newline */
+import { isJSFunction } from '@alilc/lowcode-utils';
+import { transformArrayToMap, transformStringToFunction } from './common';
+import { jsonp, request, get, post } from './request';
+import logger from './logger';
+var DS_STATUS = {
+  INIT: 'init',
+  LOADING: 'loading',
+  LOADED: 'loaded',
+  ERROR: 'error'
+};
+/**
+ * do request for standard DataSourceType
+ * @param {DataSourceType} type type of DataSourceItem
+ * @param {any} options
+ */
+export function doRequest(type, options) {
+  // eslint-disable-next-line prefer-const
+  var uri = options.uri,
+    url = options.url,
+    _options$method = options.method,
+    method = _options$method === void 0 ? 'GET' : _options$method,
+    headers = options.headers,
+    params = options.params,
+    otherProps = _objectWithoutPropertiesLoose(options, _excluded);
+  otherProps = otherProps || {};
+  if (type === 'jsonp') {
+    return jsonp(uri, params, otherProps);
+  }
+  if (type === 'fetch') {
+    switch (method.toUpperCase()) {
+      case 'GET':
+        return get(uri, params, headers, otherProps);
+      case 'POST':
+        return post(uri, params, headers, otherProps);
+      default:
+        return request(uri, method, params, headers, otherProps);
+    }
+  }
+  logger.log("Engine default dataSource does not support type:[" + type + "] dataSource request!", options);
+}
+
+// TODO: according to protocol, we should implement errorHandler/shouldFetch/willFetch/requestHandler and isSync controll.
+export var DataHelper = /*#__PURE__*/function () {
+  function DataHelper(comp, config, appHelper, parser) {
+    /**
+     * host object that will be "this" object when excuting dataHandler
+     *
+     * @type {*}
+     * @memberof DataHelper
+     */
+    this.host = void 0;
+    /**
+     * data source config
+     *
+     * @type {DataSource}
+     * @memberof DataHelper
+     */
+    this.config = void 0;
+    /**
+     * a parser function which will be called to process config data
+     * which eventually will call common/utils.processData() to process data
+     * (originalConfig) => parsedConfig
+     * @type {*}
+     * @memberof DataHelper
+     */
+    this.parser = void 0;
+    /**
+     * config.list
+     *
+     * @type {any[]}
+     * @memberof DataHelper
+     */
+    this.ajaxList = void 0;
+    this.ajaxMap = void 0;
+    this.dataSourceMap = void 0;
+    this.appHelper = void 0;
+    this.host = comp;
+    this.config = config || {};
+    this.parser = parser;
+    this.ajaxList = (config === null || config === void 0 ? void 0 : config.list) || [];
+    this.ajaxMap = transformArrayToMap(this.ajaxList, 'id');
+    this.dataSourceMap = this.generateDataSourceMap();
+    this.appHelper = appHelper;
+  }
+
+  // 更新config，只会更新配置，状态保存；
+  var _proto = DataHelper.prototype;
+  _proto.updateConfig = function updateConfig(config) {
+    var _config,
+      _this = this;
+    if (config === void 0) {
+      config = {};
+    }
+    this.config = config;
+    this.ajaxList = ((_config = config) === null || _config === void 0 ? void 0 : _config.list) || [];
+    var ajaxMap = transformArrayToMap(this.ajaxList, 'id');
+    // 删除已经移除的接口
+    Object.keys(this.ajaxMap).forEach(function (key) {
+      if (!ajaxMap[key]) {
+        delete _this.dataSourceMap[key];
+      }
+    });
+    this.ajaxMap = ajaxMap;
+    // 添加未加入到dataSourceMap中的接口
+    this.ajaxList.forEach(function (item) {
+      if (!_this.dataSourceMap[item.id]) {
+        _this.dataSourceMap[item.id] = {
+          status: DS_STATUS.INIT,
+          load: function load() {
+            for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+              args[_key] = arguments[_key];
+            }
+            // @ts-ignore
+            return _this.getDataSource.apply(_this, [item.id].concat(args));
+          }
+        };
+      }
+    });
+    return this.dataSourceMap;
+  };
+  _proto.generateDataSourceMap = function generateDataSourceMap() {
+    var _this2 = this;
+    var res = {};
+    this.ajaxList.forEach(function (item) {
+      res[item.id] = {
+        status: DS_STATUS.INIT,
+        load: function load() {
+          for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+            args[_key2] = arguments[_key2];
+          }
+          // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+          // @ts-ignore
+          return _this2.getDataSource.apply(_this2, [item.id].concat(args));
+        }
+      };
+    });
+    return res;
+  };
+  _proto.updateDataSourceMap = function updateDataSourceMap(id, data, error) {
+    this.dataSourceMap[id].error = error || undefined;
+    this.dataSourceMap[id].data = data;
+    this.dataSourceMap[id].status = error ? DS_STATUS.ERROR : DS_STATUS.LOADED;
+  }
+
+  /**
+   * get all dataSourceItems which marked as isInit === true
+   * @private
+   * @returns
+   * @memberof DataHelper
+   */;
+  _proto.getInitDataSourseConfigs = function getInitDataSourseConfigs() {
+    var _this3 = this;
+    var initConfigs = this.parser(this.ajaxList).filter(function (item) {
+      // according to [spec](https://lowcode-engine.cn/lowcode), isInit should be boolean true to be working
+      if (item.isInit === true) {
+        _this3.dataSourceMap[item.id].status = DS_STATUS.LOADING;
+        return true;
+      }
+      return false;
+    });
+    return initConfigs;
+  }
+
+  /**
+   * process all dataSourceItems which marked as isInit === true, and get dataSource request results.
+   * @public
+   * @returns
+   * @memberof DataHelper
+   */;
+  _proto.getInitData = function getInitData() {
+    var _this4 = this;
+    var initSyncData = this.getInitDataSourseConfigs();
+    // 所有 datasource 的 datahandler
+    return this.asyncDataHandler(initSyncData).then(function (res) {
+      var dataHandler = _this4.config.dataHandler;
+      return _this4.handleData(null, dataHandler, res, null);
+    });
+  };
+  _proto.getDataSource = function getDataSource(id, params, otherOptions, callback) {
+    var req = this.parser(this.ajaxMap[id]);
+    var options = req.options || {};
+    var callbackFn = callback;
+    var otherOptionsObj = otherOptions;
+    if (typeof otherOptions === 'function') {
+      callbackFn = otherOptions;
+      otherOptionsObj = {};
+    }
+    var _ref = otherOptionsObj || {},
+      headers = _ref.headers,
+      otherProps = _objectWithoutPropertiesLoose(_ref, _excluded2);
+    if (!req) {
+      logger.warn("getDataSource API named " + id + " not exist");
+      return;
+    }
+    return this.asyncDataHandler([_extends({}, req, {
+      options: _extends({}, options, {
+        // 支持参数为array的情况，当参数为array时，不做参数合并
+        params: Array.isArray(options.params) || Array.isArray(params) ? params || options.params : _extends({}, options.params, params),
+        headers: _extends({}, options.headers, headers)
+      }, otherProps)
+    })]).then(function (res) {
+      try {
+        callbackFn && callbackFn(res && res[id]);
+      } catch (e) {
+        logger.error('load请求回调函数报错', e);
+      }
+      return res && res[id];
+    })["catch"](function (err) {
+      try {
+        callbackFn && callbackFn(null, err);
+      } catch (e) {
+        logger.error('load请求回调函数报错', e);
+      }
+      return err;
+    });
+  };
+  _proto.asyncDataHandler = function asyncDataHandler(asyncDataList) {
+    var _this5 = this;
+    return new Promise(function (resolve, reject) {
+      var allReq = [];
+      asyncDataList.forEach(function (req) {
+        var id = req.id,
+          type = req.type;
+        // TODO: need refactoring to remove 'legao' related logic
+        if (!id || !type || type === 'legao') {
+          return;
+        }
+        allReq.push(req);
+      });
+      if (allReq.length === 0) {
+        resolve({});
+      }
+      var res = {};
+      Promise.all(allReq.map(function (item) {
+        return new Promise(function (innerResolve) {
+          var type = item.type,
+            id = item.id,
+            dataHandler = item.dataHandler,
+            options = item.options;
+          var fetchHandler = function fetchHandler(data, error) {
+            res[id] = _this5.handleData(id, dataHandler, data, error);
+            _this5.updateDataSourceMap(id, res[id], error);
+            innerResolve({});
+          };
+          var doFetch = function doFetch(innerType, innerOptions) {
+            var _doRequest;
+            (_doRequest = doRequest(innerType, innerOptions)) === null || _doRequest === void 0 ? void 0 : _doRequest.then(function (data) {
+              fetchHandler(data, undefined);
+            })["catch"](function (err) {
+              fetchHandler(undefined, err);
+            });
+          };
+          _this5.dataSourceMap[id].status = DS_STATUS.LOADING;
+          doFetch(type, options);
+        });
+      })).then(function () {
+        resolve(res);
+      })["catch"](function (e) {
+        reject(e);
+      });
+    });
+  }
+
+  /**
+   * process data using dataHandler
+   *
+   * @param {(string | null)} id request id, will be used in error message, can be null
+   * @param {*} dataHandler
+   * @param {*} data
+   * @param {*} error
+   * @returns
+   * @memberof DataHelper
+   */;
+  _proto.handleData = function handleData(id, dataHandler, data, error) {
+    var dataHandlerFun = dataHandler;
+    if (isJSFunction(dataHandler)) {
+      dataHandlerFun = transformStringToFunction(dataHandler.value);
+    }
+    if (!dataHandlerFun || typeof dataHandlerFun !== 'function') {
+      return data;
+    }
+    try {
+      return dataHandlerFun.call(this.host, data, error);
+    } catch (e) {
+      if (id) {
+        logger.error("[" + id + "]\u5355\u4E2A\u8BF7\u6C42\u6570\u636E\u5904\u7406\u51FD\u6570\u8FD0\u884C\u51FA\u9519", e);
+      } else {
+        logger.error('请求数据处理函数运行出错', e);
+      }
+    }
+  };
+  return DataHelper;
+}();

package/es/utils/index.d.ts

@@ -0,0 +1,3 @@
+export * from './common';
+export * from './data-helper';
+export * from './request';

package/es/utils/index.js

@@ -0,0 +1,3 @@
+export * from './common';
+export * from './data-helper';
+export * from './request';

package/es/utils/is-use-loop.d.ts

@@ -0,0 +1,2 @@
+import { IPublicTypeJSExpression } from '@alilc/lowcode-types';
+export default function isUseLoop(loop: null | any[] | IPublicTypeJSExpression, isDesignMode: boolean): boolean;

package/es/utils/is-use-loop.js

@@ -0,0 +1,16 @@
+import { isJSExpression } from '@alilc/lowcode-utils';
+
+// 1.渲染模式下，loop 是数组，则按照数组长度渲染组件
+// 2.设计模式下，loop 需要长度大于 0，按照循环模式渲染，防止无法设计的情况
+export default function isUseLoop(loop, isDesignMode) {
+  if (isJSExpression(loop)) {
+    return true;
+  }
+  if (!isDesignMode) {
+    return true;
+  }
+  if (!Array.isArray(loop)) {
+    return false;
+  }
+  return loop.length > 0;
+}

package/es/utils/logger.d.ts

@@ -0,0 +1,3 @@
+import { Logger } from '@alilc/lowcode-utils';
+declare const _default: Logger;
+export default _default;

package/es/utils/logger.js

@@ -0,0 +1,5 @@
+import { Logger } from '@alilc/lowcode-utils';
+export default new Logger({
+  level: 'warn',
+  bizName: 'renderer'
+});

package/es/utils/request.d.ts

@@ -0,0 +1,54 @@
+import 'whatwg-fetch';
+/**
+ * this is a private method, export for testing purposes only.
+ *
+ * @export
+ * @param {*} dataAPI
+ * @param {*} params
+ * @returns
+ */
+export declare function buildUrl(dataAPI: any, params: any): any;
+/**
+ * do Get request
+ *
+ * @export
+ * @param {*} dataAPI
+ * @param {*} [params={}]
+ * @param {*} [headers={}]
+ * @param {*} [otherProps={}]
+ * @returns
+ */
+export declare function get(dataAPI: any, params?: {}, headers?: {}, otherProps?: {}): Promise<unknown>;
+/**
+ * do Post request
+ *
+ * @export
+ * @param {*} dataAPI
+ * @param {*} [params={}]
+ * @param {*} [headers={}]
+ * @param {*} [otherProps={}]
+ * @returns
+ */
+export declare function post(dataAPI: any, params?: {}, headers?: any, otherProps?: {}): Promise<unknown>;
+/**
+ * do request
+ *
+ * @export
+ * @param {*} dataAPI
+ * @param {string} [method='GET']
+ * @param {*} data
+ * @param {*} [headers={}]
+ * @param {*} [otherProps={}]
+ * @returns
+ */
+export declare function request(dataAPI: any, method: string, data: any, headers?: {}, otherProps?: any): Promise<unknown>;
+/**
+ * do jsonp request
+ *
+ * @export
+ * @param {*} dataAPI
+ * @param {*} [params={}]
+ * @param {*} [otherProps={}]
+ * @returns
+ */
+export declare function jsonp(dataAPI: any, params?: {}, otherProps?: {}): Promise<unknown>;

package/es/utils/request.js

@@ -0,0 +1,209 @@
+import _extends from "@babel/runtime/helpers/extends";
+import 'whatwg-fetch';
+import fetchJsonp from 'fetch-jsonp';
+import { serializeParams } from '.';
+
+/**
+ * this is a private method, export for testing purposes only.
+ *
+ * @export
+ * @param {*} dataAPI
+ * @param {*} params
+ * @returns
+ */
+export function buildUrl(dataAPI, params) {
+  var paramStr = serializeParams(params);
+  if (paramStr) {
+    return dataAPI.indexOf('?') > 0 ? dataAPI + "&" + paramStr : dataAPI + "?" + paramStr;
+  }
+  return dataAPI;
+}
+
+/**
+ * do Get request
+ *
+ * @export
+ * @param {*} dataAPI
+ * @param {*} [params={}]
+ * @param {*} [headers={}]
+ * @param {*} [otherProps={}]
+ * @returns
+ */
+export function get(dataAPI, params, headers, otherProps) {
+  if (params === void 0) {
+    params = {};
+  }
+  if (headers === void 0) {
+    headers = {};
+  }
+  if (otherProps === void 0) {
+    otherProps = {};
+  }
+  var processedHeaders = _extends({
+    Accept: 'application/json'
+  }, headers);
+  var url = buildUrl(dataAPI, params);
+  return request(url, 'GET', null, processedHeaders, otherProps);
+}
+
+/**
+ * do Post request
+ *
+ * @export
+ * @param {*} dataAPI
+ * @param {*} [params={}]
+ * @param {*} [headers={}]
+ * @param {*} [otherProps={}]
+ * @returns
+ */
+export function post(dataAPI, params, headers, otherProps) {
+  if (params === void 0) {
+    params = {};
+  }
+  if (headers === void 0) {
+    headers = {};
+  }
+  if (otherProps === void 0) {
+    otherProps = {};
+  }
+  var processedHeaders = _extends({
+    Accept: 'application/json',
+    'Content-Type': 'application/x-www-form-urlencoded'
+  }, headers);
+  var body = processedHeaders['Content-Type'].indexOf('application/json') > -1 || Array.isArray(params) ? JSON.stringify(params) : serializeParams(params);
+  return request(dataAPI, 'POST', body, processedHeaders, otherProps);
+}
+
+/**
+ * do request
+ *
+ * @export
+ * @param {*} dataAPI
+ * @param {string} [method='GET']
+ * @param {*} data
+ * @param {*} [headers={}]
+ * @param {*} [otherProps={}]
+ * @returns
+ */
+export function request(dataAPI, method, data, headers, otherProps) {
+  if (method === void 0) {
+    method = 'GET';
+  }
+  if (headers === void 0) {
+    headers = {};
+  }
+  if (otherProps === void 0) {
+    otherProps = {};
+  }
+  var processedHeaders = headers || {};
+  var payload = data;
+  if (method === 'PUT' || method === 'DELETE') {
+    processedHeaders = _extends({
+      Accept: 'application/json',
+      'Content-Type': 'application/json'
+    }, processedHeaders);
+    payload = JSON.stringify(payload || {});
+  }
+  return new Promise(function (resolve, reject) {
+    if (otherProps.timeout) {
+      setTimeout(function () {
+        reject(new Error('timeout'));
+      }, otherProps.timeout);
+    }
+    fetch(dataAPI, _extends({
+      method: method,
+      credentials: 'include',
+      headers: processedHeaders,
+      body: payload
+    }, otherProps)).then(function (response) {
+      switch (response.status) {
+        case 200:
+        case 201:
+        case 202:
+          return response.json();
+        case 204:
+          if (method === 'DELETE') {
+            return {
+              success: true
+            };
+          } else {
+            return {
+              __success: false,
+              code: response.status
+            };
+          }
+        case 400:
+        case 401:
+        case 403:
+        case 404:
+        case 406:
+        case 410:
+        case 422:
+        case 500:
+          return response.json().then(function (res) {
+            return {
+              __success: false,
+              code: response.status,
+              data: res
+            };
+          })["catch"](function () {
+            return {
+              __success: false,
+              code: response.status
+            };
+          });
+        default:
+      }
+      return null;
+    }).then(function (json) {
+      if (!json) {
+        reject(json);
+        return;
+      }
+      if (json.__success !== false) {
+        resolve(json);
+      } else {
+        // eslint-disable-next-line no-param-reassign
+        delete json.__success;
+        reject(json);
+      }
+    })["catch"](function (err) {
+      reject(err);
+    });
+  });
+}
+
+/**
+ * do jsonp request
+ *
+ * @export
+ * @param {*} dataAPI
+ * @param {*} [params={}]
+ * @param {*} [otherProps={}]
+ * @returns
+ */
+export function jsonp(dataAPI, params, otherProps) {
+  if (params === void 0) {
+    params = {};
+  }
+  if (otherProps === void 0) {
+    otherProps = {};
+  }
+  return new Promise(function (resolve, reject) {
+    var processedOtherProps = _extends({
+      timeout: 5000
+    }, otherProps);
+    var url = buildUrl(dataAPI, params);
+    fetchJsonp(url, processedOtherProps).then(function (response) {
+      response.json();
+    }).then(function (json) {
+      if (json) {
+        resolve(json);
+      } else {
+        reject();
+      }
+    })["catch"](function (err) {
+      reject(err);
+    });
+  });
+}

package/lib/adapter/index.d.ts

@@ -0,0 +1,24 @@
+import { IRuntime, IRendererModules } from '../types';
+export declare enum Env {
+    React = "react"
+}
+declare class Adapter {
+    runtime: IRuntime;
+    builtinModules: string[];
+    env: Env;
+    renderers: IRendererModules;
+    configProvider: any;
+    constructor();
+    initRuntime(): void;
+    setRuntime(runtime: IRuntime): void;
+    isValidRuntime(runtime: IRuntime): boolean;
+    getRuntime(): IRuntime;
+    setEnv(env: Env): void;
+    isReact(): boolean;
+    setRenderers(renderers: IRendererModules): void;
+    getRenderers(): {};
+    setConfigProvider(Comp: any): void;
+    getConfigProvider(): any;
+}
+declare const _default: Adapter;
+export default _default;