@easy-editor/react-renderer 0.0.3 → 0.0.5

package/dist/esm/index.development.js

@@ -1,17 +1,7 @@
 import { observer } from 'mobx-react';
 import { createContext, useContext, useMemo, Component, forwardRef, createElement, PureComponent } from 'react';
-import { isSetterConfig, createLogger, isJSExpression, TRANSFORM_STAGE, DESIGNER_EVENT, isJSFunction, logger as logger$1 } from '@easy-editor/core';
-import { debounce, isEmpty, forEach } from 'lodash-es';
-
-function _extends() {
-  return _extends = Object.assign ? Object.assign.bind() : function (n) {
-    for (var e = 1; e < arguments.length; e++) {
-      var t = arguments[e];
-      for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]);
-    }
-    return n;
-  }, _extends.apply(null, arguments);
-}
+import { isSetterConfig, createLogger, isJSExpression, DESIGNER_EVENT, TRANSFORM_STAGE, isJSFunction, logger as logger$1 } from '@easy-editor/core';
+import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
 
 const SettingRendererContext = /*#__PURE__*/createContext({});
 const useSettingRendererContext = () => {
@@ -99,8 +89,7 @@ const SettingSetter = observer(({
     component: SetterComponent,
     props: mixedSetterProps
   } = setterManager.createSetterContent(setterType, setterProps);
-  return /*#__PURE__*/React.createElement(SetterComponent, _extends({
-    key: field.id,
+  return /*#__PURE__*/jsx(SetterComponent, {
     field: field,
     selected: field.top?.getNode(),
     initialValue: initialValue,
@@ -120,8 +109,10 @@ const SettingSetter = observer(({
       if (field.name) {
         field.parent.clearPropValue(field.name);
       }
-    }
-  }, mixedSetterProps), children);
+    },
+    ...mixedSetterProps,
+    children: children
+  }, field.id);
 });
 
 const SettingFieldItem = observer(({
@@ -131,18 +122,20 @@ const SettingFieldItem = observer(({
     customFieldItem
   } = useSettingRendererContext();
   if (customFieldItem) {
-    return customFieldItem(field, /*#__PURE__*/React.createElement(SettingSetter, {
+    return customFieldItem(field, /*#__PURE__*/jsx(SettingSetter, {
       field: field
     }));
   }
-  return /*#__PURE__*/React.createElement("div", {
-    className: "space-y-2"
-  }, /*#__PURE__*/React.createElement("label", {
-    htmlFor: field.id,
-    className: "block text-sm font-medium text-gray-700"
-  }, field.title), /*#__PURE__*/React.createElement(SettingSetter, {
-    field: field
-  }));
+  return /*#__PURE__*/jsxs("div", {
+    className: "space-y-2",
+    children: [/*#__PURE__*/jsx("label", {
+      htmlFor: field.id,
+      className: "block text-sm font-medium text-gray-700",
+      children: field.title
+    }), /*#__PURE__*/jsx(SettingSetter, {
+      field: field
+    })]
+  });
 });
 const SettingFieldGroup = observer(({
   field
@@ -151,33 +144,31 @@ const SettingFieldGroup = observer(({
     customFieldGroup
   } = useSettingRendererContext();
   if (customFieldGroup) {
-    return customFieldGroup(field, /*#__PURE__*/React.createElement(SettingSetter, {
-      field: field
-    }, field.items?.map(item => /*#__PURE__*/React.createElement(SettingFieldView, {
-      key: item.id,
+    return customFieldGroup(field, /*#__PURE__*/jsx(SettingSetter, {
+      field: field,
+      children: field.items?.map(item => /*#__PURE__*/jsx(SettingFieldView, {
+        field: item
+      }, item.id))
+    }));
+  }
+  return /*#__PURE__*/jsx(SettingSetter, {
+    field: field,
+    children: field.items?.map(item => /*#__PURE__*/jsx(SettingFieldView, {
       field: item
-    }))));
-  }
-  return /*#__PURE__*/React.createElement(SettingSetter, {
-    field: field
-  }, field.items?.map(item => /*#__PURE__*/React.createElement(SettingFieldView, {
-    key: item.id,
-    field: item
-  })));
+    }, item.id))
+  });
 });
 const SettingFieldView = ({
   field
 }) => {
   if (field.isGroup) {
-    return /*#__PURE__*/React.createElement(SettingFieldGroup, {
-      field: field,
-      key: field.id
-    });
+    return /*#__PURE__*/jsx(SettingFieldGroup, {
+      field: field
+    }, field.id);
   } else {
-    return /*#__PURE__*/React.createElement(SettingFieldItem, {
-      field: field,
-      key: field.id
-    });
+    return /*#__PURE__*/jsx(SettingFieldItem, {
+      field: field
+    }, field.id);
   }
 };
 const SettingRender = observer(props => {
@@ -205,42 +196,58 @@ const SettingRender = observer(props => {
   }, [setterManager, settingsManager, customFieldItem, customFieldGroup]);
   if (!settings) {
     // 未选中节点，提示选中 或者 显示根节点设置
-    return /*#__PURE__*/React.createElement("div", {
-      className: "lc-settings-main"
-    }, /*#__PURE__*/React.createElement("div", {
-      className: "lc-settings-notice"
-    }, /*#__PURE__*/React.createElement("p", null, "Please select a node in canvas")));
+    return /*#__PURE__*/jsx("div", {
+      className: "lc-settings-main",
+      children: /*#__PURE__*/jsx("div", {
+        className: "lc-settings-notice",
+        children: /*#__PURE__*/jsx("p", {
+          children: "Please select a node in canvas"
+        })
+      })
+    });
   }
 
   // 当节点被锁定，且未开启锁定后容器可设置属性
   if (settings.isLocked) {
-    return /*#__PURE__*/React.createElement("div", {
-      className: "lc-settings-main"
-    }, /*#__PURE__*/React.createElement("div", {
-      className: "lc-settings-notice"
-    }, /*#__PURE__*/React.createElement("p", null, "Current node is locked")));
+    return /*#__PURE__*/jsx("div", {
+      className: "lc-settings-main",
+      children: /*#__PURE__*/jsx("div", {
+        className: "lc-settings-notice",
+        children: /*#__PURE__*/jsx("p", {
+          children: "Current node is locked"
+        })
+      })
+    });
   }
   if (Array.isArray(settings.items) && settings.items.length === 0) {
-    return /*#__PURE__*/React.createElement("div", {
-      className: "lc-settings-main"
-    }, /*#__PURE__*/React.createElement("div", {
-      className: "lc-settings-notice"
-    }, /*#__PURE__*/React.createElement("p", null, "No config found for this type of component")));
+    return /*#__PURE__*/jsx("div", {
+      className: "lc-settings-main",
+      children: /*#__PURE__*/jsx("div", {
+        className: "lc-settings-notice",
+        children: /*#__PURE__*/jsx("p", {
+          children: "No config found for this type of component"
+        })
+      })
+    });
   }
   if (!settings.isSameComponent) {
     // TODO: future support 获取设置项交集编辑
-    return /*#__PURE__*/React.createElement("div", {
-      className: "lc-settings-main"
-    }, /*#__PURE__*/React.createElement("div", {
-      className: "lc-settings-notice"
-    }, /*#__PURE__*/React.createElement("p", null, "Please select same kind of components")));
-  }
-  return /*#__PURE__*/React.createElement(SettingRendererContext.Provider, {
-    value: ctx
-  }, items?.map(item => /*#__PURE__*/React.createElement(SettingFieldView, {
-    key: item.id,
-    field: item
-  })));
+    return /*#__PURE__*/jsx("div", {
+      className: "lc-settings-main",
+      children: /*#__PURE__*/jsx("div", {
+        className: "lc-settings-notice",
+        children: /*#__PURE__*/jsx("p", {
+          children: "Please select same kind of components"
+        })
+      })
+    });
+  }
+  return /*#__PURE__*/jsx(SettingRendererContext.Provider, {
+    value: ctx,
+    children: items?.map(item => /*#__PURE__*/jsx(SettingFieldView, {
+      field: item
+    }, item.id))
+  });
 });
 
 class Adapter {
@@ -263,6 +270,566 @@ class Adapter {
 }
 const adapter = new Adapter();
 
+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 symbolTag = '[object Symbol]';
+function isSymbol(value) {
+  return typeof value == 'symbol' || isObjectLike(value) && baseGetTag(value) == symbolTag;
+}
+
+var isArray = Array.isArray;
+
+var reWhitespace = /\s/;
+function trimmedEndIndex(string) {
+  var index = string.length;
+  while (index-- && reWhitespace.test(string.charAt(index))) {}
+  return index;
+}
+
+var reTrimStart = /^\s+/;
+function baseTrim(string) {
+  return string ? string.slice(0, trimmedEndIndex(string) + 1).replace(reTrimStart, '') : string;
+}
+
+function isObject(value) {
+  var type = typeof value;
+  return value != null && (type == 'object' || type == 'function');
+}
+
+var NAN = 0 / 0;
+var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;
+var reIsBinary = /^0b[01]+$/i;
+var reIsOctal = /^0o[0-7]+$/i;
+var freeParseInt = parseInt;
+function toNumber(value) {
+  if (typeof value == 'number') {
+    return value;
+  }
+  if (isSymbol(value)) {
+    return NAN;
+  }
+  if (isObject(value)) {
+    var other = typeof value.valueOf == 'function' ? value.valueOf() : value;
+    value = isObject(other) ? other + '' : other;
+  }
+  if (typeof value != 'string') {
+    return value === 0 ? value : +value;
+  }
+  value = baseTrim(value);
+  var isBinary = reIsBinary.test(value);
+  return isBinary || reIsOctal.test(value) ? freeParseInt(value.slice(2), isBinary ? 2 : 8) : reIsBadHex.test(value) ? NAN : +value;
+}
+
+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$1 = 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$1),
+  promiseCtorString = toSource(Promise$1),
+  setCtorString = toSource(Set),
+  weakMapCtorString = toSource(WeakMap);
+var getTag = baseGetTag;
+if (DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag || Map$1 && getTag(new Map$1()) != 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);
+
+var now = function () {
+  return root.Date.now();
+};
+
+var FUNC_ERROR_TEXT = 'Expected a function';
+var nativeMax = Math.max,
+  nativeMin = Math.min;
+function debounce(func, wait, options) {
+  var lastArgs,
+    lastThis,
+    maxWait,
+    result,
+    timerId,
+    lastCallTime,
+    lastInvokeTime = 0,
+    leading = false,
+    maxing = false,
+    trailing = true;
+  if (typeof func != 'function') {
+    throw new TypeError(FUNC_ERROR_TEXT);
+  }
+  wait = toNumber(wait) || 0;
+  if (isObject(options)) {
+    leading = !!options.leading;
+    maxing = 'maxWait' in options;
+    maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait;
+    trailing = 'trailing' in options ? !!options.trailing : trailing;
+  }
+  function invokeFunc(time) {
+    var args = lastArgs,
+      thisArg = lastThis;
+    lastArgs = lastThis = undefined;
+    lastInvokeTime = time;
+    result = func.apply(thisArg, args);
+    return result;
+  }
+  function leadingEdge(time) {
+    lastInvokeTime = time;
+    timerId = setTimeout(timerExpired, wait);
+    return leading ? invokeFunc(time) : result;
+  }
+  function remainingWait(time) {
+    var timeSinceLastCall = time - lastCallTime,
+      timeSinceLastInvoke = time - lastInvokeTime,
+      timeWaiting = wait - timeSinceLastCall;
+    return maxing ? nativeMin(timeWaiting, maxWait - timeSinceLastInvoke) : timeWaiting;
+  }
+  function shouldInvoke(time) {
+    var timeSinceLastCall = time - lastCallTime,
+      timeSinceLastInvoke = time - lastInvokeTime;
+    return lastCallTime === undefined || timeSinceLastCall >= wait || timeSinceLastCall < 0 || maxing && timeSinceLastInvoke >= maxWait;
+  }
+  function timerExpired() {
+    var time = now();
+    if (shouldInvoke(time)) {
+      return trailingEdge(time);
+    }
+    timerId = setTimeout(timerExpired, remainingWait(time));
+  }
+  function trailingEdge(time) {
+    timerId = undefined;
+    if (trailing && lastArgs) {
+      return invokeFunc(time);
+    }
+    lastArgs = lastThis = undefined;
+    return result;
+  }
+  function cancel() {
+    if (timerId !== undefined) {
+      clearTimeout(timerId);
+    }
+    lastInvokeTime = 0;
+    lastArgs = lastCallTime = lastThis = timerId = undefined;
+  }
+  function flush() {
+    return timerId === undefined ? result : trailingEdge(now());
+  }
+  function debounced() {
+    var time = now(),
+      isInvoking = shouldInvoke(time);
+    lastArgs = arguments;
+    lastThis = this;
+    lastCallTime = time;
+    if (isInvoking) {
+      if (timerId === undefined) {
+        return leadingEdge(lastCallTime);
+      }
+      if (maxing) {
+        clearTimeout(timerId);
+        timerId = setTimeout(timerExpired, wait);
+        return invokeFunc(lastCallTime);
+      }
+    }
+    if (timerId === undefined) {
+      timerId = setTimeout(timerExpired, wait);
+    }
+    return result;
+  }
+  debounced.cancel = cancel;
+  debounced.flush = flush;
+  return debounced;
+}
+
+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 RendererContext = /*#__PURE__*/createContext({});
 const useRendererContext = () => {
   try {
@@ -1033,9 +1600,6 @@ const leafWrapper = (Comp, {
   return LeafWrapper;
 };
 
-/**
- * execute method in schema.lifeCycles with context
- */
 function executeLifeCycleMethod(context, schema, method, args) {
   if (!context || !isSchema(schema) || !method) {
     return;
@@ -1748,16 +2312,19 @@ function baseRendererFactory() {
       return this.__instanceMap[id];
     }
     __renderContextProvider = (customProps, children) => {
-      return /*#__PURE__*/React.createElement(RendererContext.Provider, {
+      return /*#__PURE__*/jsx(RendererContext.Provider, {
         value: {
           ...this.context,
           blockContext: this,
           ...(customProps || {})
-        }
-      }, children || this.__createDom());
+        },
+        children: children || this.__createDom()
+      });
     };
     __renderContextConsumer = children => {
-      return /*#__PURE__*/React.createElement(RendererContext.Consumer, null, children);
+      return /*#__PURE__*/jsx(RendererContext.Consumer, {
+        children: children
+      });
     };
     __getHOCWrappedComponent(OriginalComp, info) {
       let Comp = OriginalComp;
@@ -1821,12 +2388,13 @@ function baseRendererFactory() {
         ...(typeof this.props.style === 'object' ? this.props.style : {})
       };
       const id = this.props.id || parsedProps.id;
-      return /*#__PURE__*/React.createElement("div", {
+      return /*#__PURE__*/jsx("div", {
         ref: this.__getRef,
         className: className,
         id: id,
-        style: style
-      }, children);
+        style: style,
+        children: children
+      });
     }
     __checkSchema = (schema, originalExtraComponents = []) => {
       let extraComponents = originalExtraComponents;
@@ -1962,7 +2530,7 @@ const FaultComponent = ({
   error
 }) => {
   logger.error(`${componentName} 组件渲染异常, 异常原因: ${error?.message || error || '未知'}`);
-  return /*#__PURE__*/React.createElement("div", {
+  return /*#__PURE__*/jsxs("div", {
     role: "alert",
     "aria-label": `${componentName} 组件渲染异常`,
     style: {
@@ -1973,8 +2541,9 @@ const FaultComponent = ({
       fontSize: '15px',
       color: '#ef4444',
       border: '2px solid #ef4444'
-    }
-  }, componentName, " \u7EC4\u4EF6\u6E32\u67D3\u5F02\u5E38\uFF0C\u8BF7\u67E5\u770B\u63A7\u5236\u53F0\u65E5\u5FD7");
+    },
+    children: [componentName, " \u7EC4\u4EF6\u6E32\u67D3\u5F02\u5E38\uFF0C\u8BF7\u67E5\u770B\u63A7\u5236\u53F0\u65E5\u5FD7"]
+  });
 };
 
 const NotFoundComponent = ({
@@ -1984,9 +2553,11 @@ const NotFoundComponent = ({
 }) => {
   logger.warn(`Component ${componentName} not found`);
   if (enableStrictNotFoundMode) {
-    return /*#__PURE__*/React.createElement(React.Fragment, null, `${componentName} Component Not Found`);
+    return /*#__PURE__*/jsx(Fragment, {
+      children: `${componentName} Component Not Found`
+    });
   }
-  return /*#__PURE__*/React.createElement("div", {
+  return /*#__PURE__*/jsx("div", {
     role: "alert",
     "aria-label": `${componentName} component not found`,
     style: {
@@ -1997,8 +2568,9 @@ const NotFoundComponent = ({
       fontSize: '15px',
       color: '#eab308',
       border: '2px solid #eab308'
-    }
-  }, `${componentName} Component Not Found`);
+    },
+    children: `${componentName} Component Not Found`
+  });
 };
 
 function rendererFactory() {
@@ -2085,21 +2657,21 @@ function rendererFactory() {
       if (!Comp) {
         return null;
       }
-      return /*#__PURE__*/React.createElement(RendererContext.Provider, {
+      return /*#__PURE__*/jsx(RendererContext.Provider, {
         value: {
           appHelper,
           components: allComponents,
           engine: this
-        }
-      }, /*#__PURE__*/React.createElement(Comp, _extends({
-        key: schema.__ctx && `${schema.__ctx.lceKey}_${schema.__ctx.idx || '0'}`
-        // ref={this.__getRef}
-        ,
-        __appHelper: appHelper,
-        __components: allComponents,
-        __schema: schema,
-        __designMode: designMode
-      }, this.props)));
+        },
+        children: /*#__PURE__*/jsx(Comp, {
+          // ref={this.__getRef}
+          __appHelper: appHelper,
+          __components: allComponents,
+          __schema: schema,
+          __designMode: designMode,
+          ...this.props
+        }, schema.__ctx && `${schema.__ctx.lceKey}_${schema.__ctx.idx || '0'}`)
+      });
     }
   };
 }