@easy-editor/renderer-core 1.0.0

package/dist/index.cjs

@@ -0,0 +1,971 @@
+'use strict';
+
+var core = require('@easy-editor/core');
+
+const classnames = (...args) => {
+  return args.filter(Boolean).join(' ');
+};
+
+var freeGlobal = typeof global == 'object' && global && global.Object === Object && global;
+
+var freeSelf = typeof self == 'object' && self && self.Object === Object && self;
+var root = freeGlobal || freeSelf || Function('return this')();
+
+var Symbol = root.Symbol;
+
+var objectProto$7 = Object.prototype;
+var hasOwnProperty$5 = objectProto$7.hasOwnProperty;
+var nativeObjectToString$1 = objectProto$7.toString;
+var symToStringTag$1 = Symbol ? Symbol.toStringTag : undefined;
+function getRawTag(value) {
+  var isOwn = hasOwnProperty$5.call(value, symToStringTag$1),
+    tag = value[symToStringTag$1];
+  try {
+    value[symToStringTag$1] = undefined;
+    var unmasked = true;
+  } catch (e) {}
+  var result = nativeObjectToString$1.call(value);
+  if (unmasked) {
+    if (isOwn) {
+      value[symToStringTag$1] = tag;
+    } else {
+      delete value[symToStringTag$1];
+    }
+  }
+  return result;
+}
+
+var objectProto$6 = Object.prototype;
+var nativeObjectToString = objectProto$6.toString;
+function objectToString(value) {
+  return nativeObjectToString.call(value);
+}
+
+var nullTag = '[object Null]',
+  undefinedTag = '[object Undefined]';
+var symToStringTag = Symbol ? Symbol.toStringTag : undefined;
+function baseGetTag(value) {
+  if (value == null) {
+    return value === undefined ? undefinedTag : nullTag;
+  }
+  return symToStringTag && symToStringTag in Object(value) ? getRawTag(value) : objectToString(value);
+}
+
+function isObjectLike(value) {
+  return value != null && typeof value == 'object';
+}
+
+var isArray = Array.isArray;
+
+function isObject(value) {
+  var type = typeof value;
+  return value != null && (type == 'object' || type == 'function');
+}
+
+function identity(value) {
+  return value;
+}
+
+var asyncTag = '[object AsyncFunction]',
+  funcTag$1 = '[object Function]',
+  genTag = '[object GeneratorFunction]',
+  proxyTag = '[object Proxy]';
+function isFunction(value) {
+  if (!isObject(value)) {
+    return false;
+  }
+  var tag = baseGetTag(value);
+  return tag == funcTag$1 || tag == genTag || tag == asyncTag || tag == proxyTag;
+}
+
+var coreJsData = root['__core-js_shared__'];
+
+var maskSrcKey = function () {
+  var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || '');
+  return uid ? 'Symbol(src)_1.' + uid : '';
+}();
+function isMasked(func) {
+  return !!maskSrcKey && maskSrcKey in func;
+}
+
+var funcProto$1 = Function.prototype;
+var funcToString$1 = funcProto$1.toString;
+function toSource(func) {
+  if (func != null) {
+    try {
+      return funcToString$1.call(func);
+    } catch (e) {}
+    try {
+      return func + '';
+    } catch (e) {}
+  }
+  return '';
+}
+
+var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
+var reIsHostCtor = /^\[object .+?Constructor\]$/;
+var funcProto = Function.prototype,
+  objectProto$5 = Object.prototype;
+var funcToString = funcProto.toString;
+var hasOwnProperty$4 = objectProto$5.hasOwnProperty;
+var reIsNative = RegExp('^' + funcToString.call(hasOwnProperty$4).replace(reRegExpChar, '\\$&').replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$');
+function baseIsNative(value) {
+  if (!isObject(value) || isMasked(value)) {
+    return false;
+  }
+  var pattern = isFunction(value) ? reIsNative : reIsHostCtor;
+  return pattern.test(toSource(value));
+}
+
+function getValue$1(object, key) {
+  return object == null ? undefined : object[key];
+}
+
+function getNative(object, key) {
+  var value = getValue$1(object, key);
+  return baseIsNative(value) ? value : undefined;
+}
+
+var WeakMap = getNative(root, 'WeakMap');
+
+function arrayEach(array, iteratee) {
+  var index = -1,
+    length = array == null ? 0 : array.length;
+  while (++index < length) {
+    if (iteratee(array[index], index, array) === false) {
+      break;
+    }
+  }
+  return array;
+}
+
+var MAX_SAFE_INTEGER$1 = 9007199254740991;
+var reIsUint = /^(?:0|[1-9]\d*)$/;
+function isIndex(value, length) {
+  var type = typeof value;
+  length = length == null ? MAX_SAFE_INTEGER$1 : length;
+  return !!length && (type == 'number' || type != 'symbol' && reIsUint.test(value)) && value > -1 && value % 1 == 0 && value < length;
+}
+
+var MAX_SAFE_INTEGER = 9007199254740991;
+function isLength(value) {
+  return typeof value == 'number' && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
+}
+
+function isArrayLike(value) {
+  return value != null && isLength(value.length) && !isFunction(value);
+}
+
+var objectProto$4 = Object.prototype;
+function isPrototype(value) {
+  var Ctor = value && value.constructor,
+    proto = typeof Ctor == 'function' && Ctor.prototype || objectProto$4;
+  return value === proto;
+}
+
+function baseTimes(n, iteratee) {
+  var index = -1,
+    result = Array(n);
+  while (++index < n) {
+    result[index] = iteratee(index);
+  }
+  return result;
+}
+
+var argsTag$1 = '[object Arguments]';
+function baseIsArguments(value) {
+  return isObjectLike(value) && baseGetTag(value) == argsTag$1;
+}
+
+var objectProto$3 = Object.prototype;
+var hasOwnProperty$3 = objectProto$3.hasOwnProperty;
+var propertyIsEnumerable = objectProto$3.propertyIsEnumerable;
+var isArguments = baseIsArguments(function () {
+  return arguments;
+}()) ? baseIsArguments : function (value) {
+  return isObjectLike(value) && hasOwnProperty$3.call(value, 'callee') && !propertyIsEnumerable.call(value, 'callee');
+};
+
+function stubFalse() {
+  return false;
+}
+
+var freeExports$1 = typeof exports == 'object' && exports && !exports.nodeType && exports;
+var freeModule$1 = freeExports$1 && typeof module == 'object' && module && !module.nodeType && module;
+var moduleExports$1 = freeModule$1 && freeModule$1.exports === freeExports$1;
+var Buffer = moduleExports$1 ? root.Buffer : undefined;
+var nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined;
+var isBuffer = nativeIsBuffer || stubFalse;
+
+var argsTag = '[object Arguments]',
+  arrayTag = '[object Array]',
+  boolTag = '[object Boolean]',
+  dateTag = '[object Date]',
+  errorTag = '[object Error]',
+  funcTag = '[object Function]',
+  mapTag$2 = '[object Map]',
+  numberTag = '[object Number]',
+  objectTag$1 = '[object Object]',
+  regexpTag = '[object RegExp]',
+  setTag$2 = '[object Set]',
+  stringTag = '[object String]',
+  weakMapTag$1 = '[object WeakMap]';
+var arrayBufferTag = '[object ArrayBuffer]',
+  dataViewTag$1 = '[object DataView]',
+  float32Tag = '[object Float32Array]',
+  float64Tag = '[object Float64Array]',
+  int8Tag = '[object Int8Array]',
+  int16Tag = '[object Int16Array]',
+  int32Tag = '[object Int32Array]',
+  uint8Tag = '[object Uint8Array]',
+  uint8ClampedTag = '[object Uint8ClampedArray]',
+  uint16Tag = '[object Uint16Array]',
+  uint32Tag = '[object Uint32Array]';
+var typedArrayTags = {};
+typedArrayTags[float32Tag] = typedArrayTags[float64Tag] = typedArrayTags[int8Tag] = typedArrayTags[int16Tag] = typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] = typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] = typedArrayTags[uint32Tag] = true;
+typedArrayTags[argsTag] = typedArrayTags[arrayTag] = typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] = typedArrayTags[dataViewTag$1] = typedArrayTags[dateTag] = typedArrayTags[errorTag] = typedArrayTags[funcTag] = typedArrayTags[mapTag$2] = typedArrayTags[numberTag] = typedArrayTags[objectTag$1] = typedArrayTags[regexpTag] = typedArrayTags[setTag$2] = typedArrayTags[stringTag] = typedArrayTags[weakMapTag$1] = false;
+function baseIsTypedArray(value) {
+  return isObjectLike(value) && isLength(value.length) && !!typedArrayTags[baseGetTag(value)];
+}
+
+function baseUnary(func) {
+  return function (value) {
+    return func(value);
+  };
+}
+
+var freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;
+var freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;
+var moduleExports = freeModule && freeModule.exports === freeExports;
+var freeProcess = moduleExports && freeGlobal.process;
+var nodeUtil = function () {
+  try {
+    var types = freeModule && freeModule.require && freeModule.require('util').types;
+    if (types) {
+      return types;
+    }
+    return freeProcess && freeProcess.binding && freeProcess.binding('util');
+  } catch (e) {}
+}();
+
+var nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;
+var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;
+
+var objectProto$2 = Object.prototype;
+var hasOwnProperty$2 = objectProto$2.hasOwnProperty;
+function arrayLikeKeys(value, inherited) {
+  var isArr = isArray(value),
+    isArg = !isArr && isArguments(value),
+    isBuff = !isArr && !isArg && isBuffer(value),
+    isType = !isArr && !isArg && !isBuff && isTypedArray(value),
+    skipIndexes = isArr || isArg || isBuff || isType,
+    result = skipIndexes ? baseTimes(value.length, String) : [],
+    length = result.length;
+  for (var key in value) {
+    if ((hasOwnProperty$2.call(value, key)) && !(skipIndexes && (
+    key == 'length' ||
+    isBuff && (key == 'offset' || key == 'parent') ||
+    isType && (key == 'buffer' || key == 'byteLength' || key == 'byteOffset') ||
+    isIndex(key, length)))) {
+      result.push(key);
+    }
+  }
+  return result;
+}
+
+function overArg(func, transform) {
+  return function (arg) {
+    return func(transform(arg));
+  };
+}
+
+var nativeKeys = overArg(Object.keys, Object);
+
+var objectProto$1 = Object.prototype;
+var hasOwnProperty$1 = objectProto$1.hasOwnProperty;
+function baseKeys(object) {
+  if (!isPrototype(object)) {
+    return nativeKeys(object);
+  }
+  var result = [];
+  for (var key in Object(object)) {
+    if (hasOwnProperty$1.call(object, key) && key != 'constructor') {
+      result.push(key);
+    }
+  }
+  return result;
+}
+
+function keys(object) {
+  return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);
+}
+
+var Map = getNative(root, 'Map');
+
+var DataView = getNative(root, 'DataView');
+
+var Promise$1 = getNative(root, 'Promise');
+
+var Set = getNative(root, 'Set');
+
+var mapTag$1 = '[object Map]',
+  objectTag = '[object Object]',
+  promiseTag = '[object Promise]',
+  setTag$1 = '[object Set]',
+  weakMapTag = '[object WeakMap]';
+var dataViewTag = '[object DataView]';
+var dataViewCtorString = toSource(DataView),
+  mapCtorString = toSource(Map),
+  promiseCtorString = toSource(Promise$1),
+  setCtorString = toSource(Set),
+  weakMapCtorString = toSource(WeakMap);
+var getTag = baseGetTag;
+if (DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag || Map && getTag(new Map()) != mapTag$1 || Promise$1 && getTag(Promise$1.resolve()) != promiseTag || Set && getTag(new Set()) != setTag$1 || WeakMap && getTag(new WeakMap()) != weakMapTag) {
+  getTag = function (value) {
+    var result = baseGetTag(value),
+      Ctor = result == objectTag ? value.constructor : undefined,
+      ctorString = Ctor ? toSource(Ctor) : '';
+    if (ctorString) {
+      switch (ctorString) {
+        case dataViewCtorString:
+          return dataViewTag;
+        case mapCtorString:
+          return mapTag$1;
+        case promiseCtorString:
+          return promiseTag;
+        case setCtorString:
+          return setTag$1;
+        case weakMapCtorString:
+          return weakMapTag;
+      }
+    }
+    return result;
+  };
+}
+
+function createBaseFor(fromRight) {
+  return function (object, iteratee, keysFunc) {
+    var index = -1,
+      iterable = Object(object),
+      props = keysFunc(object),
+      length = props.length;
+    while (length--) {
+      var key = props[++index];
+      if (iteratee(iterable[key], key, iterable) === false) {
+        break;
+      }
+    }
+    return object;
+  };
+}
+
+var baseFor = createBaseFor();
+
+function baseForOwn(object, iteratee) {
+  return object && baseFor(object, iteratee, keys);
+}
+
+function createBaseEach(eachFunc, fromRight) {
+  return function (collection, iteratee) {
+    if (collection == null) {
+      return collection;
+    }
+    if (!isArrayLike(collection)) {
+      return eachFunc(collection, iteratee);
+    }
+    var length = collection.length,
+      index = -1,
+      iterable = Object(collection);
+    while (++index < length) {
+      if (iteratee(iterable[index], index, iterable) === false) {
+        break;
+      }
+    }
+    return collection;
+  };
+}
+
+var baseEach = createBaseEach(baseForOwn);
+
+function castFunction(value) {
+  return typeof value == 'function' ? value : identity;
+}
+
+function forEach(collection, iteratee) {
+  var func = isArray(collection) ? arrayEach : baseEach;
+  return func(collection, castFunction(iteratee));
+}
+
+var mapTag = '[object Map]',
+  setTag = '[object Set]';
+var objectProto = Object.prototype;
+var hasOwnProperty = objectProto.hasOwnProperty;
+function isEmpty(value) {
+  if (value == null) {
+    return true;
+  }
+  if (isArrayLike(value) && (isArray(value) || typeof value == 'string' || typeof value.splice == 'function' || isBuffer(value) || isTypedArray(value) || isArguments(value))) {
+    return !value.length;
+  }
+  var tag = getTag(value);
+  if (tag == mapTag || tag == setTag) {
+    return !value.size;
+  }
+  if (isPrototype(value)) {
+    return !baseKeys(value).length;
+  }
+  for (var key in value) {
+    if (hasOwnProperty.call(value, key)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+const logger = core.createLogger('Renderer');
+
+const PropTypes2 = true;
+const inSameDomain = () => {
+  try {
+    return window.parent !== window && window.parent.location.host === window.location.host;
+  } catch (e) {
+    return false;
+  }
+};
+const getFileCssName = fileName => {
+  if (!fileName) {
+    return;
+  }
+  const name = fileName.replace(/([A-Z])/g, '-$1').toLowerCase();
+  return `lce-${name}`.split('-').filter(p => !!p).join('-');
+};
+const isSchema = schema => {
+  if (!schema) {
+    return false;
+  }
+  if (schema.componentName === 'Leaf' || schema.componentName === 'Slot') {
+    return true;
+  }
+  if (Array.isArray(schema)) {
+    return schema.every(item => isSchema(item));
+  }
+  const isValidProps = props => {
+    if (!props) {
+      return false;
+    }
+    return typeof schema.props === 'object' && !Array.isArray(props);
+  };
+  return !!(schema.componentName && isValidProps(schema.props));
+};
+const getValue = (obj, path, defaultValue = {}) => {
+  if (Array.isArray(obj)) {
+    return defaultValue;
+  }
+  if (!obj || typeof obj !== 'object') {
+    return defaultValue;
+  }
+  const res = path.split('.').reduce((pre, cur) => {
+    return pre && pre[cur];
+  }, obj);
+  if (res === undefined) {
+    return defaultValue;
+  }
+  return res;
+};
+const transformArrayToMap = (arr, key, overwrite = true) => {
+  if (!arr || !Array.isArray(arr)) {
+    return {};
+  }
+  const res = {};
+  arr.forEach(item => {
+    const curKey = item[key];
+    if (item[key] === undefined) {
+      return;
+    }
+    if (res[curKey] && !overwrite) {
+      return;
+    }
+    res[curKey] = item;
+  });
+  return res;
+};
+const parseData = (schema, self, options = {}) => {
+  if (core.isJSExpression(schema)) {
+    return parseExpression({
+      str: schema,
+      self,
+      thisRequired: true,
+      logScope: options.logScope
+    });
+  }
+  if (typeof schema === 'string') {
+    return schema.trim();
+  } else if (Array.isArray(schema)) {
+    return schema.map(item => parseData(item, self, options));
+  } else if (typeof schema === 'function') {
+    return schema.bind(self);
+  } else if (typeof schema === 'object') {
+    if (!schema) {
+      return schema;
+    }
+    const res = {};
+    Object.entries(schema).forEach(([key, val]) => {
+      if (key.startsWith('__')) {
+        return;
+      }
+      res[key] = parseData(val, self, options);
+    });
+    return res;
+  }
+  return schema;
+};
+const isUseLoop = (loop, isDesignMode) => {
+  if (!isDesignMode) {
+    return true;
+  }
+  if (!Array.isArray(loop)) {
+    return false;
+  }
+  return loop.length > 0;
+};
+const checkPropTypes = (value, name, rule, componentName) => {
+  let ruleFunction = rule;
+  if (typeof rule === 'string') {
+    ruleFunction = new Function(`"use strict"; const PropTypes = arguments[0]; return ${rule}`)(PropTypes2);
+  }
+  if (!ruleFunction || typeof ruleFunction !== 'function') {
+    logger.warn('checkPropTypes should have a function type rule argument');
+    return true;
+  }
+  const err = ruleFunction({
+    [name]: value
+  }, name, componentName, 'prop', null
+  );
+  if (err) {
+    logger.warn(err);
+  }
+  return !err;
+};
+const transformStringToFunction = str => {
+  if (typeof str !== 'string') {
+    return str;
+  }
+  if (inSameDomain() && window.parent.__newFunc) {
+    return window.parent.__newFunc(`"use strict"; return ${str}`)();
+  } else {
+    return new Function(`"use strict"; return ${str}`)();
+  }
+};
+function parseExpression(a, b, c = false) {
+  let str;
+  let self;
+  let thisRequired;
+  let logScope;
+  if (typeof a === 'object' && b === undefined) {
+    str = a.str;
+    self = a.self;
+    thisRequired = a.thisRequired;
+    logScope = a.logScope;
+  } else {
+    str = a;
+    self = b;
+    thisRequired = c;
+  }
+  try {
+    const contextArr = ['"use strict";', 'var __self = arguments[0];'];
+    contextArr.push('return ');
+    let tarStr;
+    tarStr = (str.value || '').trim();
+    tarStr = tarStr.replace(/this(\W|$)/g, (_a, b) => `__self${b}`);
+    tarStr = contextArr.join('\n') + tarStr;
+    if (inSameDomain() && window.parent.__newFunc) {
+      return window.parent.__newFunc(tarStr)(self);
+    }
+    const code = `with(${thisRequired ? '{}' : '$scope || {}'}) { ${tarStr} }`;
+    return new Function('$scope', code)(self);
+  } catch (err) {
+    logger.error(`${logScope || ''} parseExpression.error`, err, str, self?.__self ?? self);
+    return undefined;
+  }
+}
+const parseThisRequiredExpression = (str, self) => {
+  return parseExpression(str, self, true);
+};
+const isString = str => {
+  return {}.toString.call(str) === '[object String]';
+};
+const capitalizeFirstLetter = word => {
+  if (!word || !isString(word) || word.length === 0) {
+    return word;
+  }
+  return word[0].toUpperCase() + word.slice(1);
+};
+const serializeParams = obj => {
+  const result = [];
+  forEach(obj, (val, key) => {
+    if (val === null || val === undefined || val === '') {
+      return;
+    }
+    if (typeof val === 'object') {
+      result.push(`${key}=${encodeURIComponent(JSON.stringify(val))}`);
+    } else {
+      result.push(`${key}=${encodeURIComponent(val)}`);
+    }
+  });
+  return result.join('&');
+};
+
+const buildUrl = (dataAPI, params) => {
+  const paramStr = serializeParams(params);
+  if (paramStr) {
+    return dataAPI.indexOf('?') > 0 ? `${dataAPI}&${paramStr}` : `${dataAPI}?${paramStr}`;
+  }
+  return dataAPI;
+};
+const get = (dataAPI, params = {}, headers = {}, otherProps = {}) => {
+  const processedHeaders = {
+    Accept: 'application/json',
+    ...headers
+  };
+  const url = buildUrl(dataAPI, params);
+  return request(url, 'GET', null, processedHeaders, otherProps);
+};
+const post = (dataAPI, params = {}, headers = {}, otherProps = {}) => {
+  const processedHeaders = {
+    Accept: 'application/json',
+    'Content-Type': 'application/x-www-form-urlencoded',
+    ...headers
+  };
+  const body = processedHeaders['Content-Type'].indexOf('application/json') > -1 || Array.isArray(params) ? JSON.stringify(params) : serializeParams(params);
+  return request(dataAPI, 'POST', body, processedHeaders, otherProps);
+};
+const request = (dataAPI, method = 'GET', data, headers = {}, otherProps = {}) => {
+  let processedHeaders = headers || {};
+  let payload = data;
+  if (method === 'PUT' || method === 'DELETE') {
+    processedHeaders = {
+      Accept: 'application/json',
+      'Content-Type': 'application/json',
+      ...processedHeaders
+    };
+    payload = JSON.stringify(payload || {});
+  }
+  return new Promise((resolve, reject) => {
+    if (otherProps.timeout) {
+      setTimeout(() => {
+        reject(new Error('timeout'));
+      }, otherProps.timeout);
+    }
+    fetch(dataAPI, {
+      method,
+      credentials: 'include',
+      headers: processedHeaders,
+      body: payload,
+      ...otherProps
+    }).then(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(res => {
+            return {
+              __success: false,
+              code: response.status,
+              data: res
+            };
+          }).catch(() => {
+            return {
+              __success: false,
+              code: response.status
+            };
+          });
+      }
+      return null;
+    }).then(json => {
+      if (!json) {
+        reject(json);
+        return;
+      }
+      if (json.__success !== false) {
+        resolve(json);
+      } else {
+        json.__success = undefined;
+        reject(json);
+      }
+    }).catch(err => {
+      reject(err);
+    });
+  });
+};
+
+const DS_STATUS = {
+  INIT: 'init',
+  LOADING: 'loading',
+  LOADED: 'loaded',
+  ERROR: 'error'
+};
+const doRequest = (type, options) => {
+  let {
+    uri,
+    url,
+    method = 'GET',
+    headers,
+    params,
+    ...otherProps
+  } = options;
+  otherProps = 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);
+};
+class DataHelper {
+  host;
+  config;
+  parser;
+  ajaxList;
+  dataHandler;
+  ajaxMap;
+  dataSourceMap;
+  appHelper;
+  constructor(comp, config, appHelper, parser) {
+    this.host = comp;
+    this.config = config || {};
+    this.parser = parser;
+    this.ajaxList = config?.list || [];
+    this.ajaxMap = transformArrayToMap(this.ajaxList, 'id');
+    this.dataSourceMap = this.generateDataSourceMap();
+    this.appHelper = appHelper;
+    this.dataHandler = config?.dataHandler ? parseExpression(config?.dataHandler, comp, true) : undefined;
+  }
+  updateConfig(config = {}) {
+    this.config = config;
+    this.ajaxList = config?.list || [];
+    const ajaxMap = transformArrayToMap(this.ajaxList, 'id');
+    Object.keys(this.ajaxMap).forEach(key => {
+      if (!ajaxMap[key]) {
+        delete this.dataSourceMap[key];
+      }
+    });
+    this.ajaxMap = ajaxMap;
+    this.ajaxList.forEach(item => {
+      if (!this.dataSourceMap[item.id]) {
+        this.dataSourceMap[item.id] = {
+          status: DS_STATUS.INIT,
+          load: (...args) => {
+            return this.getDataSource(item.id, ...args);
+          }
+        };
+      }
+    });
+    return this.dataSourceMap;
+  }
+  generateDataSourceMap() {
+    const res = {};
+    this.ajaxList.forEach(item => {
+      res[item.id] = {
+        status: DS_STATUS.INIT,
+        load: (...args) => {
+          return this.getDataSource(item.id, ...args);
+        }
+      };
+    });
+    return res;
+  }
+  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;
+  }
+  getInitDataSourseConfigs() {
+    const initConfigs = this.parser(this.ajaxList).filter(item => {
+      if (item.isInit === true) {
+        this.dataSourceMap[item.id].status = DS_STATUS.LOADING;
+        return true;
+      }
+      return false;
+    });
+    return initConfigs;
+  }
+  getInitData() {
+    const initSyncData = this.getInitDataSourseConfigs();
+    return this.asyncDataHandler(initSyncData).then(res => {
+      const {
+        dataHandler
+      } = this.config;
+      return this.handleData(null, dataHandler, res, null);
+    });
+  }
+  async reloadDataSource() {
+    const dataSourceMap = await this.getInitData();
+    if (isEmpty(dataSourceMap)) {
+      return;
+    }
+    this.host.setState(dataSourceMap);
+    if (this.dataHandler) {
+      this.dataHandler(dataSourceMap);
+    }
+  }
+  getDataSource(id, params, otherOptions, callback) {
+    const req = this.parser(this.ajaxMap[id]);
+    const options = req.options || {};
+    let callbackFn = callback;
+    let otherOptionsObj = otherOptions;
+    if (typeof otherOptions === 'function') {
+      callbackFn = otherOptions;
+      otherOptionsObj = {};
+    }
+    const {
+      headers,
+      ...otherProps
+    } = otherOptionsObj || {};
+    if (!req) {
+      logger.warn(`getDataSource API named ${id} not exist`);
+      return;
+    }
+    return this.asyncDataHandler([{
+      ...req,
+      options: {
+        ...options,
+        params: Array.isArray(options.params) || Array.isArray(params) ? params || options.params : {
+          ...options.params,
+          ...params
+        },
+        headers: {
+          ...options.headers,
+          ...headers
+        },
+        ...otherProps
+      }
+    }]).then(res => {
+      try {
+        callbackFn && callbackFn(res && res[id]);
+      } catch (e) {
+        logger.error('load请求回调函数报错', e);
+      }
+      return res && res[id];
+    }).catch(err => {
+      try {
+        callbackFn && callbackFn(null, err);
+      } catch (e) {
+        logger.error('load请求回调函数报错', e);
+      }
+      return err;
+    });
+  }
+  asyncDataHandler(asyncDataList) {
+    return new Promise((resolve, reject) => {
+      const allReq = [];
+      asyncDataList.forEach(req => {
+        const {
+          id,
+          type
+        } = req;
+        if (!id || !type || type === 'legao') {
+          return;
+        }
+        allReq.push(req);
+      });
+      if (allReq.length === 0) {
+        resolve({});
+      }
+      const res = {};
+      Promise.all(allReq.map(item => {
+        return new Promise(innerResolve => {
+          const {
+            type,
+            id,
+            dataHandler,
+            options
+          } = item;
+          const fetchHandler = (data, error) => {
+            res[id] = this.handleData(id, dataHandler, data, error);
+            this.updateDataSourceMap(id, res[id], error);
+            innerResolve({});
+          };
+          const doFetch = (innerType, innerOptions) => {
+            doRequest(innerType, innerOptions)?.then(data => {
+              fetchHandler(data, undefined);
+            }).catch(err => {
+              fetchHandler(undefined, err);
+            });
+          };
+          this.dataSourceMap[id].status = DS_STATUS.LOADING;
+          doFetch(type, options);
+        });
+      })).then(() => {
+        resolve(res);
+      }).catch(e => {
+        reject(e);
+      });
+    });
+  }
+  handleData(id, dataHandler, data, error) {
+    let dataHandlerFun = dataHandler;
+    if (core.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}]单个请求数据处理函数运行出错`, e);
+      } else {
+        logger.error('请求数据处理函数运行出错', e);
+      }
+    }
+  }
+}
+
+exports.DataHelper = DataHelper;
+exports.buildUrl = buildUrl;
+exports.capitalizeFirstLetter = capitalizeFirstLetter;
+exports.checkPropTypes = checkPropTypes;
+exports.classnames = classnames;
+exports.doRequest = doRequest;
+exports.get = get;
+exports.getFileCssName = getFileCssName;
+exports.getValue = getValue;
+exports.inSameDomain = inSameDomain;
+exports.isSchema = isSchema;
+exports.isString = isString;
+exports.isUseLoop = isUseLoop;
+exports.logger = logger;
+exports.parseData = parseData;
+exports.parseExpression = parseExpression;
+exports.parseThisRequiredExpression = parseThisRequiredExpression;
+exports.post = post;
+exports.request = request;
+exports.serializeParams = serializeParams;
+exports.transformArrayToMap = transformArrayToMap;
+exports.transformStringToFunction = transformStringToFunction;