@wibetter/json-utils 1.3.1 → 5.0.1

package/dist/index.esm.js

@@ -1,25 +1,27 @@
+import { cloneDeep, isEqual as isEqual$1 } from 'lodash';
+
 /** js对象数据深拷贝，避免数据联动 */
 function objClone(targetObj) {
-  var newObj = JSON.stringify(targetObj);
-  return JSON.parse(newObj);
+  // const newObj = JSON.stringify(targetObj);
+  // return JSON.parse(newObj);
+  return cloneDeep(targetObj);
 }
-/** 对比两个json数据是否相等 */
 
+/** 对比两个json数据是否相等 */
 function isEqual(targetObj, nextTargetObj) {
-  return JSON.stringify(targetObj) === JSON.stringify(nextTargetObj);
+  // return JSON.stringify(targetObj) === JSON.stringify(nextTargetObj);
+  return isEqual$1(targetObj, nextTargetObj);
 }
+
 /** 判断当前属性是否存在
  * 备注：要识别boolean类型的数值 */
-
-function exitPropertie(targetPropertie) {
-  var exitPropertie = false;
-
-  if (targetPropertie !== undefined && targetPropertie !== null) {
-    // targetPropertie 等于""、0、false时均认为是存在的属性
-    exitPropertie = true;
+function hasProperties(targetProperties) {
+  var hasProperties = false;
+  if (targetProperties !== undefined && targetProperties !== null) {
+    // targetProperties 等于""、0、false时均认为是存在的属性
+    hasProperties = true;
   }
-
-  return exitPropertie;
+  return hasProperties;
 }
 
 /**
@@ -29,21 +31,16 @@ function exitPropertie(targetPropertie) {
  * targetJsonDataObj: json数据对象
  * useObjClone: 是否进行深拷贝，避免影响原有数据。（默认不进行深拷贝）
  */
-
 function getJsonDataByKeyRoute(keyRoute, targetJsonDataObj, useObjClone) {
   var curJsonDataObj = targetJsonDataObj;
-
   if (useObjClone) {
     curJsonDataObj = objClone(targetJsonDataObj); // 进行深拷贝，避免影响原有数据
   }
-
   if (keyRoute) {
     var keyRouteArr = keyRoute.split('-');
-
     for (var index = 0, size = keyRouteArr.length; index < size; index++) {
       // 1、获取当前的jsonKey值
       var curKey = keyRouteArr[index];
-
       if (curKey) {
         // 只有curKey不为空的时候才进行赋值
         // 2、根据key值获取对应的数据对象
@@ -51,7 +48,6 @@ function getJsonDataByKeyRoute(keyRoute, targetJsonDataObj, useObjClone) {
       }
     }
   }
-
   return curJsonDataObj;
 }
 
@@ -62,40 +58,33 @@ function getJsonDataByKeyRoute(keyRoute, targetJsonDataObj, useObjClone) {
  * targetJsonSchemaObj: schema数据对象
  * useObjClone: 是否进行深拷贝，避免影响原有数据。（默认不进行深拷贝）
  */
-
 function getSchemaByIndexRoute(indexRoute, targetJsonSchemaObj, useObjClone) {
   var curJsonSchemaObj = targetJsonSchemaObj;
-
   if (useObjClone) {
     curJsonSchemaObj = objClone(targetJsonSchemaObj); // 进行深拷贝，避免影响原有数据
   }
-
   if (indexRoute) {
     var indexRouteArr = indexRoute.split('-');
-
     for (var index = 0, size = indexRouteArr.length; index < size; index++) {
       // 获取指定路径的json数据对象，需要按以下步骤（备注：确保是符合规则的json格式数据）
       var curIndex = indexRouteArr[index];
-
       if (curIndex === '0' && (curJsonSchemaObj.format === 'array' || curJsonSchemaObj.format === 'radio' || curJsonSchemaObj.format === 'single-select' || curJsonSchemaObj.format === 'select') && curJsonSchemaObj.items) {
         // 从items中获取数据
         curJsonSchemaObj = curJsonSchemaObj.items;
       } else if (curIndex) {
-        var curKeyTemp = '0'; // 1、先根据路径值获取key值
-
+        var curKeyTemp = '0';
+        // 1、先根据路径值获取key值
         if (curJsonSchemaObj.propertyOrder) {
           curKeyTemp = curJsonSchemaObj.propertyOrder[curIndex];
         } else if (curJsonSchemaObj.properties) {
           var propertyOrder = Object.keys(curJsonSchemaObj.properties);
           curKeyTemp = propertyOrder[curIndex];
-        } // 2、根据key值获取对应的json数据对象
-
-
+        }
+        // 2、根据key值获取对应的json数据对象
         curJsonSchemaObj = curJsonSchemaObj.properties[curKeyTemp];
       }
     }
   }
-
   return curJsonSchemaObj;
 }
 
@@ -106,28 +95,22 @@ function getSchemaByIndexRoute(indexRoute, targetJsonSchemaObj, useObjClone) {
  * targetJsonSchemaObj: schema数据对象
  * useObjClone: 是否进行深拷贝，避免影响原有数据。（默认不进行深拷贝）
  */
-
 function getSchemaByKeyRoute(keyRoute, targetJsonSchemaObj, useObjClone) {
   var curJsonSchemaObj = targetJsonSchemaObj;
-
   if (useObjClone) {
     curJsonSchemaObj = objClone(targetJsonSchemaObj); // 进行深拷贝，避免影响原有数据
   }
-
   if (keyRoute && curJsonSchemaObj) {
     var keyRouteArr = keyRoute.split('-');
-
     for (var index = 0, size = keyRouteArr.length; index < size; index++) {
       // 获取指定路径的json数据对象，需要按以下步骤（备注：确保是符合规则的json格式数据）
       var curKey = keyRouteArr[index];
-
       if (curKey && curJsonSchemaObj.properties) {
         // 根据key值获取对应的json数据对象
         curJsonSchemaObj = curJsonSchemaObj.properties[curKey];
       }
     }
   }
-
   return curJsonSchemaObj;
 }
 
@@ -141,34 +124,28 @@ function indexRoute2keyRoute(indexRoute, targetJsonSchemaObj) {
   var curJsonSchemaObj = targetJsonSchemaObj;
   var curKeyRoute = '';
   var indexRouteArr = indexRoute.split('-');
-
   for (var index = 0, size = indexRouteArr.length; index < size; index++) {
     // 获取指定路径的json数据对象，需要按以下步骤（备注：确保是符合规则的json格式数据）
     var curIndex = indexRouteArr[index];
-
     if (curIndex === '0' && curJsonSchemaObj.items) {
       // 从items中获取数据
       curJsonSchemaObj = curJsonSchemaObj.items; // 对象类型数据引用
-
       curKeyRoute = curKeyRoute ? curKeyRoute + "-items" : 'items';
     } else if (curIndex) {
       // 1、先根据路径值获取key值
-      var curKey = '0'; // 1、先根据路径值获取key值
-
+      var curKey = '0';
+      // 1、先根据路径值获取key值
       if (curJsonSchemaObj.propertyOrder) {
         curKey = curJsonSchemaObj.propertyOrder[curIndex];
       } else if (curJsonSchemaObj.properties) {
         var propertyOrder = Object.keys(curJsonSchemaObj.properties);
         curKey = propertyOrder[curIndex];
-      } // 2、根据key值获取对应的json数据对象
-
-
+      }
+      // 2、根据key值获取对应的json数据对象
       curJsonSchemaObj = curJsonSchemaObj.properties[curKey]; // 对象类型数据引用
-
       curKeyRoute = curKeyRoute ? curKeyRoute + "-" + curKey : curKey;
     }
   }
-
   return curKeyRoute;
 }
 
@@ -182,33 +159,29 @@ function keyRoute2indexRoute(keyRoute, targetJsonSchemaObj) {
   var curJsonSchemaObj = targetJsonSchemaObj;
   var curIndexRoute = '';
   var keyRouteArr = keyRoute.split('-');
-
   for (var index = 0, size = keyRouteArr.length; index < size; index++) {
     var curKey = keyRouteArr[index];
-
     if (curKey) {
       // 1、先根据路径值获取key值
-      var curIndex = -1; // 1、先根据路径值获取key值
-
+      var curIndex = -1;
+      // 1、先根据路径值获取key值
       if (curJsonSchemaObj.propertyOrder) {
-        curIndex = curJsonSchemaObj.propertyOrder.indexOf(curKey); // 2、根据key值获取对应的json数据对象
-
+        curIndex = curJsonSchemaObj.propertyOrder.indexOf(curKey);
+        // 2、根据key值获取对应的json数据对象
         curJsonSchemaObj = curJsonSchemaObj.properties[curKey]; // 对象类型数据引用
       } else if (curJsonSchemaObj.properties) {
         var propertyOrder = Object.keys(curJsonSchemaObj.properties);
-        curIndex = propertyOrder.indexOf(curKey); // 2、根据key值获取对应的json数据对象
-
+        curIndex = propertyOrder.indexOf(curKey);
+        // 2、根据key值获取对应的json数据对象
         curJsonSchemaObj = curJsonSchemaObj.properties[curKey]; // 对象类型数据引用
       } else if (curJsonSchemaObj.items) {
-        // 兼容数据类型
-        curIndex = curKey;
+        // 兼容数组类型
+        curIndex = 0; // curKey;
         curJsonSchemaObj = curJsonSchemaObj.items; // 对象类型数据引用
       }
-
       curIndexRoute = curIndexRoute ? curIndexRoute + "-" + curIndex : curIndex.toString();
     }
   }
-
   return curIndexRoute;
 }
 
@@ -929,9 +902,9 @@ var initHtmlAreaData = {
  *  required：存放所有子字段的key值，用于验证子字段项是否存在，同时required可充当排序功能
  *  propertyOrder：按序存放所有子字段的key值（排序功能）
  * */
+
 /** 新版EventData
  * type: emit 的默认数据 */
-
 var initEventData = {
   type: 'object',
   format: 'event',
@@ -974,9 +947,9 @@ var initEventData = {
   required: ['type', 'trigger', 'eventData'],
   propertyOrder: ['type', 'trigger', 'eventData']
 };
+
 /** 新版EventData
  * type: on 的默认数据 */
-
 var initEventDataTypeON = {
   type: 'object',
   format: 'event',
@@ -1066,8 +1039,9 @@ var initDataSourceData = {
   },
   required: ['type', 'data', 'filter'],
   propertyOrder: ['type', 'data', 'filter']
-}; // 默认是用于展示local本地数据源的，如果展示远程数据源使用initDataSourceDataV2
+};
 
+// 默认是用于展示local本地数据源的，如果展示远程数据源使用initDataSourceDataV2
 var initDataSourceDataV2 = {
   type: 'object',
   format: 'datasource',
@@ -1184,8 +1158,9 @@ var initDynamicData = {
   },
   required: ['type', 'config', 'data', 'localFilter'],
   propertyOrder: ['type', 'config', 'data', 'localFilter']
-}; // 动态数据对应的空json数据内容
+};
 
+// 动态数据对应的空json数据内容
 var EmptyDynamicDataCont = {
   type: 'local',
   config: {
@@ -1198,7 +1173,7 @@ var EmptyDynamicDataCont = {
   data: '{}',
   // 用于存储结果数据
   localFilter: 'return data;'
-}; // 示例对象: 动态数据类型-接口数据 对应的json数据内容
+};
 
 /* widget类型字段
  * 【字段属性说明】
@@ -1221,9 +1196,9 @@ var initWidgetData = {
   // 字段项的说明和描述
   isRequired: false,
   readOnly: true // 默认只读
-
 };
 
+// 类型数据清单
 var TypeDataList = {
   jsonschema: initJSONSchemaData,
   input: initInputData,
@@ -1253,125 +1228,120 @@ var TypeDataList = {
   datasource: initDataSourceData,
   event: initEventData,
   widget: initWidgetData
-}; // 事件类型数据
+};
 
+// 事件类型数据
 var EventTypeDataList = {
   on: initEventDataTypeON,
   emit: initEventData
-}; // 数据源类型
+};
 
+// 数据源类型
 var DataSourceTypeList = {
   local: initDataSourceData,
   remote: initDataSourceDataV2
 };
 
+// 判断是否是URL地址类型
 function isURL(s) {
   return /^http[s]?:\/\/.*/.test(s);
-} // 判断是否是字符串类型
-
+}
+// 判断是否是字符串类型
 function isString(o) {
   return Object.prototype.toString.call(o).slice(8, -1) === 'String';
-} // 判断是否是数字类型
-
+}
+// 判断是否是数字类型
 function isNumber(value) {
   return typeof value === 'number' || Object.prototype.toString.call(value) === '[object Number]';
-} // 判断是否是Boolean类型
-
+}
+// 判断是否是Boolean类型
 function isBoolean(o) {
   return Object.prototype.toString.call(o).slice(8, -1) === 'Boolean';
-} // 判断是否是年月日的时间类型
+}
 
+// 判断是否是年月日的时间类型
 function isDateStr(dateStr) {
   return /^\d{4}-\d{2}-\d{2}$/.test(dateStr);
-} // 判断是否是年月日时分的时间类型
+}
 
+// 判断是否是年月日时分的时间类型
 function isDateTimeStr(dateStr) {
   return /^\d{4}-\d{2}-\d{2}\s\d{2}:\d{2}$/.test(dateStr) || /^\d{4}-\d{2}-\d{2}\s\d{2}:\d{2}:\d{2}$/.test(dateStr);
-} // 判断是否是时分的时间类型
+}
 
+// 判断是否是时分的时间类型
 function isTimeStr(dateStr) {
   return /^\d{2}:\d{2}:\d{2}$/.test(dateStr) || /^\d{2}:\d{2}$/.test(dateStr);
 }
+
 /**
  *  判断是否是数组类型
  * */
-
 function isArray(curObj) {
   var isArray = false;
-
   if (Object.prototype.toString.call(curObj).slice(8, -1) === 'Array') {
     isArray = true;
   }
-
   return isArray;
 }
+
 /**
  *  判断是否是select多选类型(基础类型的array)
  *  select类型一定是一个array类型
  * */
-
 function isSelect(curObj) {
   if (!isArray(curObj)) {
     return false;
   }
-
   for (var ind = 0, size = curObj.length; ind < size; ind++) {
     var arrItem = curObj[ind];
-
     if (!isString(arrItem)) {
       // 只要有一个不是string类型就认为不是select
       return false;
     }
   }
-
   return true;
 }
+
 /**
  *  判断是否是对象类型
  * */
-
 function isObject(curObj) {
   var isObject = false;
-
   if (Object.prototype.toString.call(curObj).slice(8, -1) === 'Object') {
     isObject = true;
   }
-
   return isObject;
 }
+
 /**
  *  判断是否是单位类型
  * */
-
 function isQuantity(val) {
-  var isObject = false; // 获取当前计量单位元素可选的单位类型
-
+  var isObject = false;
+  // 获取当前计量单位元素可选的单位类型
   var quantityList = TypeDataList.quantity.properties.quantity.enum;
-
   if (quantityList.indexOf(val) >= 0) {
     isObject = true;
   }
-
   return isObject;
 }
+
 /**
  *  判断是否是颜色值
  * */
-
 function isColor(colorVal) {
   return /^#[0-9a-f]{6}$/.test(colorVal) || /^#[0-9a-f]{3}$/.test(colorVal);
 }
+
 /**
  *  判断是否是函数类型
  * */
-
 function isFunction(curObj) {
   var isFunction = false;
-
   if (Object.prototype.toString.call(curObj).slice(8, -1) === 'Function') {
     isFunction = true;
   }
-
   return isFunction;
 }
 
@@ -1379,15 +1349,14 @@ function isFunction(curObj) {
  * json2schema：根据json数据内容获取对应的schema数据
  * 当前包含三个转换方法：baseJson2Schema、objectJson2Schema、arrayJson2Schema
  * */
+
 /**
  * 基础类型的jsonData转schema
  * 备注：目前可转换Boolean、Number、URL、Date、DateTime、Time、color、json类型
  * 其中textarea、radio、codearea和htmlarea的数值不好和input区分，故均转换为input类型
  * */
-
 function baseJson2Schema(jsonData) {
   var curJsonSchema = '';
-
   if (isBoolean(jsonData)) {
     // 1、Boolean类型
     curJsonSchema = objClone(TypeDataList.boolean);
@@ -1413,7 +1382,6 @@ function baseJson2Schema(jsonData) {
     try {
       // json数据类型：进行格式化（检查是否是合格的json字符串数据）
       var jsonDataObj = JSON.parse(jsonData);
-
       if (isNumber(jsonDataObj)) {
         // 简单数字字符串类型数值统一认为是字符串类型
         curJsonSchema = objClone(TypeDataList.input);
@@ -1432,21 +1400,17 @@ function baseJson2Schema(jsonData) {
       }
     }
   }
-
   return curJsonSchema;
 }
+
 /**
  * Object类型的jsonData转schema
  * 备注：目前可转换datasource、event、quantity、object四种对象类型
  * */
-
-
 function objectJson2Schema(jsonData) {
   var curJsonSchema;
-
   if (isObject(jsonData)) {
     var properties = Object.keys(jsonData);
-
     if (jsonData.data && jsonData.filter && properties.length === 2) {
       // DataSource数据源类型
       if (isArray(jsonData.data) || isObject(jsonData.data)) {
@@ -1469,34 +1433,30 @@ function objectJson2Schema(jsonData) {
       // 其他非固定格式的Object类型
       curJsonSchema = objClone(TypeDataList['empty-object']); // 新建空数组对象schema
       // 遍历子数据项目
-
       Object.keys(jsonData).map(function (jsonKey) {
         var curJsonItem = jsonData[jsonKey];
         curJsonSchema.properties[jsonKey] = json2schema(curJsonItem);
       });
     }
   }
-
   return curJsonSchema;
 }
+
 /**
  * Array类型的jsonData转schema
  * 备注：目前可转换select、array两种数组类型
  * */
-
-
 function arrayJson2Schema(jsonData) {
-  var curJsonSchema; // 判断是否是数组类型
-
+  var curJsonSchema;
+  // 判断是否是数组类型
   if (jsonData && isArray(jsonData)) {
     // 判断是否select类型（select类型是字符串类型的array）
     if (isSelect(jsonData)) {
-      curJsonSchema = objClone(TypeDataList.select); // 将当前jsonData的值设置为select的选项值
-
+      curJsonSchema = objClone(TypeDataList.select);
+      // 将当前jsonData的值设置为select的选项值
       curJsonSchema.items.enum = jsonData;
       var enumextraLength = curJsonSchema.items.enumextra.length;
       var arrLength = jsonData.length;
-
       if (arrLength > enumextraLength) {
         // 如果当前jsonDats的数值个数大于selectSchemaData的选项个数，则需要进行补充
         for (var ind = enumextraLength, size = arrLength; ind < size; ind++) {
@@ -1506,23 +1466,18 @@ function arrayJson2Schema(jsonData) {
     } else {
       curJsonSchema = objClone(TypeDataList['empty-array']); // 新建空数组对象schema
       // 根据第一个数组项获取items的schema对象
-
       var arrItemObj = json2schema(jsonData[0]); // 正常情况下，Array的一级子对象是Object类型
-
       curJsonSchema.items.properties = arrItemObj.properties;
     }
   }
-
   return curJsonSchema;
 }
+
 /**
  * 根据jsonData生成一份对应的jsonSchema
  * */
-
-
 function json2schema(jsonData) {
   var curJsonSchema = {};
-
   if (jsonData && isObject(jsonData)) {
     curJsonSchema = objectJson2Schema(jsonData);
   } else if (jsonData && isArray(jsonData)) {
@@ -1530,7 +1485,6 @@ function json2schema(jsonData) {
   } else {
     curJsonSchema = baseJson2Schema(jsonData);
   }
-
   return curJsonSchema;
 }
 
@@ -1544,7 +1498,6 @@ function json2schema(jsonData) {
  */
 function getCurrentFormat(targetJsonData) {
   var currentType = targetJsonData && targetJsonData.format;
-
   if (!currentType) {
     if (targetJsonData && targetJsonData.type) {
       currentType = targetJsonData.type;
@@ -1552,22 +1505,18 @@ function getCurrentFormat(targetJsonData) {
       currentType = 'input';
     }
   }
-
   return currentType;
 }
+
 /** 判断是否为空的Schema
  * 包括 通用schema和组件配置专用的schema
  * */
-
 function isEmptySchema(targetJsonSchema) {
   var isEmpty = true;
-
   if (!targetJsonSchema) {
     return isEmpty;
   }
-
   var curType = getCurrentFormat(targetJsonSchema);
-
   if (curType === 'object' && targetJsonSchema.properties && targetJsonSchema.propertyOrder && targetJsonSchema.propertyOrder.length > 0) {
     // Object对象类型
     isEmpty = false;
@@ -1578,104 +1527,89 @@ function isEmptySchema(targetJsonSchema) {
     // 其他基本类型
     isEmpty = false;
   }
-
   return isEmpty;
 }
+
 /** 判断是否为空的WidgetSchema
  * 备注：WidgetSchema 一级字段必须为object，且有三个子属性：func、style、data
  * */
-
 function isEmptyWidgetSchema(targetJsonSchema) {
   var isEmpty = true;
-
   if (targetJsonSchema) {
     var curType = getCurrentFormat(targetJsonSchema);
-
     if (curType === 'object' && targetJsonSchema.properties && targetJsonSchema.propertyOrder && targetJsonSchema.propertyOrder.length > 0) {
       var funcSchema = targetJsonSchema.properties.func || {};
       var styleSchema = targetJsonSchema.properties.style || {};
       var dataSchema = targetJsonSchema.properties.data || {};
-
       if (funcSchema.propertyOrder && funcSchema.propertyOrder.length > 0 || styleSchema.propertyOrder && styleSchema.propertyOrder.length > 0 || dataSchema.propertyOrder && dataSchema.propertyOrder.length > 0) {
         isEmpty = false;
       }
     }
   }
-
   return isEmpty;
 }
+
 /** 判断是否为用于组件配置的jsonSchema数据
  * 备注：一级字段必须为object（用于规避非法的jsonSchema数据，以及结构单一的jsonSchema数据）
  * 且具备固定的三个子属性（func、style、data）
  * */
-
 function isUsedToWidgetConfig(targetJsonSchema) {
   var isWidgetConfig = false;
-
   if (targetJsonSchema) {
     var curType = getCurrentFormat(targetJsonSchema);
-
     if (curType === 'object' && targetJsonSchema.properties && targetJsonSchema.propertyOrder && targetJsonSchema.properties.func && targetJsonSchema.properties.style && targetJsonSchema.properties.data) {
       isWidgetConfig = true;
     }
   }
-
   return isWidgetConfig;
 }
+
 /**
  *  判断是否是最新版的schema数据
  *  备注：确保当前schema数据是通过@wibetter/json-schema-editor生成的
  * */
-
 function isNewSchemaData(schemaData) {
   var isNewVersion = false;
-  var lastUpdateTime = schemaData.lastUpdateTime; // 从那一刻开始就认为是新版JSONSchema
-
+  var lastUpdateTime = schemaData.lastUpdateTime;
+  // 从那一刻开始就认为是新版JSONSchema
   var newVersionTime = new Date('2020-07-29T07:30:00.691Z').getTime();
-
   if (lastUpdateTime && new Date(lastUpdateTime).getTime() >= newVersionTime) {
     isNewVersion = true;
   }
-
   return isNewVersion;
 }
+
 /** 根据format判断是否是容器类型字段
  *  容器类型字段：func、style、data、object
  *  主要用于判断当前元素点击新增时是添加子元素还是添加兄弟节点，容器类型点击新增时则添加子节点。
  *  备注：array类型字段只有固定的一个items属性，不能新增其他子元素。
  * */
-
 function isBoxSchemaData(format) {
   var isBoxSchema = false;
-
   if (format === 'object' || format === 'func' || format === 'style' || format === 'data' || format === 'widgets' || format === 'func-schema' || format === 'style-schema' || format === 'data-schema' || format === 'event-schema' || format === 'widgets-schema') {
     isBoxSchema = true;
   }
-
   return isBoxSchema;
 }
+
 /** 根据format判断是否是一级类型字段
  *  一级类型字段：func、style、data、props、event-schema、widgets
  *  备注：一级类型字段不允许拖拽和复制
  * */
-
 function isFirstSchemaData(format) {
   var isFirstSchema = false;
-
   if (format === 'func' || format === 'style' || format === 'data' || format === 'props' || format === 'event-schema' || format === 'widgets') {
     isFirstSchema = true;
   }
-
   return isFirstSchema;
 }
+
 /** 判断是否是结构化的schema数据，
  *  判定条件：一级schema为object类型，其所有二级schema也为object类型
  * */
-
 function isStructuredSchema(jsonSchema) {
   var isStructured = true;
   var currentType = jsonSchema.type || getCurrentFormat(jsonSchema);
-
   if (currentType !== 'object' || !jsonSchema.propertyOrder || !jsonSchema.properties) {
     isStructured = false;
   } else {
@@ -1683,70 +1617,61 @@ function isStructuredSchema(jsonSchema) {
       /** 1. 获取当前schema对象 */
       var curSchemaData = jsonSchema.properties[key];
       /** 2. 判断是否是容器类型元素，如果是则禁止选中 */
-
       var curType = jsonSchema.type || getCurrentFormat(curSchemaData);
-
       if (curType !== 'object' || !curSchemaData.propertyOrder || !curSchemaData.properties) {
         isStructured = false;
       }
     });
   }
-
   return isStructured;
 }
+
 /**
  * 判断是否是同一个父元素
  * 备注：用于判断两个元素是否在同一个父级容器中
  */
-
 function isSameParent(curIndex, targetIndex) {
   var curIndexArr = curIndex.split('-');
   var targetIndexArr = targetIndex.split('-');
   curIndexArr.pop();
   targetIndexArr.pop();
-
   if (curIndexArr.join('-') === targetIndexArr.join('-')) {
     return true;
   }
-
   return false;
 }
+
 /**
  * 判断当前元素在目标元素的位置 前 or 后（根据当前元素的位置和目标元素的位置）
  */
-
 function getCurPosition(curIndex, targetIndex) {
   var curIndexArr = curIndex.split('-');
   var targetIndexArr = targetIndex.split('-');
   var curPosition = 'before'; // 默认在目标元素的前面
   // 使用短的路径进行遍历（避免空指针）
-
   var forEachArr = curIndexArr.length > targetIndexArr.length ? targetIndexArr : curIndexArr;
-
   for (var index = 0, size = forEachArr.length; index < size; index += 1) {
     var curIndexItem = Number(curIndexArr[index]);
     var targetIndexItem = Number(targetIndexArr[index]);
-
     if (curIndexItem > targetIndexItem) {
       curPosition = 'after'; // 表示当前元素在目标元素的后面
     }
   }
-
   return curPosition;
 }
+
 /**
  * 获取父元素的路径值
  */
-
 function getParentIndexRoute(curIndexRoute) {
   var curIndexArr = curIndexRoute.split('-');
   curIndexArr.pop();
   return curIndexArr.join('-');
 }
+
 /**
  * 获取下一个兄弟元素的路径值
  */
-
 function getNextIndexRoute(curIndexRoute) {
   var curIndexArr = curIndexRoute.split('-');
   var lastIndex = curIndexArr.pop();
@@ -1754,29 +1679,29 @@ function getNextIndexRoute(curIndexRoute) {
   curIndexArr.push("" + endIndex);
   return curIndexArr.join('-');
 }
+
 /**
  * 获取父元素的路径值和当前index
  */
-
 function getParentIndexRoute_CurIndex(curIndexRoute) {
   var curIndexArr = curIndexRoute.split('-');
   var curIndex = curIndexArr.pop();
   return [curIndexArr.join('-'), curIndex];
 }
+
 /**
  * 将当前路径值向前移动一位
  */
-
 function moveForward(curIndexRoute) {
   var curIndexArr = curIndexRoute.split('-');
   var curIndex = curIndexArr.pop();
   curIndexArr.push(Number(curIndex) - 1);
   return curIndexArr.join('-');
 }
+
 /**
  * 将当前路径值向后移动一位
  */
-
 function moveBackward(curIndexRoute) {
   var curIndexArr = curIndexRoute.split('-');
   var curIndex = curIndexArr.pop();
@@ -1803,41 +1728,35 @@ function moveBackward(curIndexRoute) {
  *   }
  * }
  */
+
 /**
  * Object类型的schema元数据分析
  * */
-
 function objectSchema2JsonData$1(jsonSchema, analyzerResult) {
   var curAnalyzerResult = analyzerResult || {};
-
   if (isObject(jsonSchema) && jsonSchema.type === 'object' && jsonSchema.properties) {
     var curPropertyOrder = [];
-
     if (jsonSchema.propertyOrder) {
       curPropertyOrder = jsonSchema.propertyOrder;
     } else {
       curPropertyOrder = Object.keys(jsonSchema.properties);
     }
-
     curPropertyOrder.map(function (jsonKey) {
       var curSchema = jsonSchema.properties[jsonKey];
       curAnalyzerResult = metaElemAnalyzer(curSchema, curAnalyzerResult);
     });
   }
-
   return curAnalyzerResult;
 }
-/** 主方法 */
-
 
+/** 主方法 */
 function metaElemAnalyzer(curJsonSchemaObj, analyzerResult) {
   // 根据analyzerResult是否为空，判断是否是最外层的调用
   var isFirstAnalyzer = !analyzerResult ? true : false;
-  var curAnalyzerResult = analyzerResult || {}; // 根据当前schem数据分析使用到的元数据情况
-
+  var curAnalyzerResult = analyzerResult || {};
+  // 根据当前schem数据分析使用到的元数据情况
   if (curJsonSchemaObj && JSON.stringify(curJsonSchemaObj) !== '{}') {
     var curFormat = getCurrentFormat(curJsonSchemaObj);
-
     if (curFormat === 'object' || curFormat === 'func' || curFormat === 'style' || curFormat === 'data') {
       // 最外层的schema类型不进行统计
       if (!isFirstAnalyzer && curAnalyzerResult['object']) {
@@ -1845,7 +1764,6 @@ function metaElemAnalyzer(curJsonSchemaObj, analyzerResult) {
       } else if (!isFirstAnalyzer) {
         curAnalyzerResult['object'] = 1;
       }
-
       curAnalyzerResult = objectSchema2JsonData$1(curJsonSchemaObj, curAnalyzerResult);
     } else if (curFormat === 'array') {
       // 最外层的schema类型不进行统计
@@ -1854,7 +1772,6 @@ function metaElemAnalyzer(curJsonSchemaObj, analyzerResult) {
       } else if (!isFirstAnalyzer) {
         curAnalyzerResult['array'] = 1;
       }
-
       curJsonSchemaObj = curJsonSchemaObj.items;
       curAnalyzerResult = objectSchema2JsonData$1(curJsonSchemaObj, curAnalyzerResult);
     } else {
@@ -1865,7 +1782,6 @@ function metaElemAnalyzer(curJsonSchemaObj, analyzerResult) {
       }
     }
   }
-
   return curAnalyzerResult;
 }
 
@@ -1877,61 +1793,51 @@ function metaElemAnalyzer(curJsonSchemaObj, analyzerResult) {
 function oldSchemaToNewSchema(oldSchema) {
   var newJSONSchema = objClone(oldSchema); // 进行深拷贝，避免影响原有数据;
   // 1.根据原有的description值生成title值
-
   if (!newJSONSchema.title && newJSONSchema.description) {
     newJSONSchema.title = newJSONSchema.description;
-  } // 2.当format为空时重新进行赋值
-
-
+  }
+  // 2.当format为空时重新进行赋值
   if (!newJSONSchema.format) {
     newJSONSchema.format = getCurrentFormat(newJSONSchema);
-  } // 3.不需要default属性的类型自动删除
-
-
-  if ((newJSONSchema.format === 'quantity' || newJSONSchema.format === 'array' || newJSONSchema.format === 'datasource' || newJSONSchema.format === 'event' || newJSONSchema.format === 'object' || newJSONSchema.format === 'radio' || newJSONSchema.format === 'select') && exitPropertie(newJSONSchema.default)) {
+  }
+  // 3.不需要default属性的类型自动删除
+  if ((newJSONSchema.format === 'quantity' || newJSONSchema.format === 'array' || newJSONSchema.format === 'datasource' || newJSONSchema.format === 'event' || newJSONSchema.format === 'object' || newJSONSchema.format === 'radio' || newJSONSchema.format === 'select') && hasProperties(newJSONSchema.default)) {
     delete newJSONSchema.default; // 单位计量输入类型的默认值改放unit属性中
-  } // 转换旧版的radio类型的数据结构
-
-
+  }
+  // 转换旧版的radio类型的数据结构
   if (newJSONSchema.format === 'radio') {
     newJSONSchema.type = 'string';
-
     if (newJSONSchema.enum && newJSONSchema.enumextra) {
       // 统一转换至items
       newJSONSchema.items = {
         type: 'string',
         enum: objClone(newJSONSchema.enum),
         enumextra: objClone(newJSONSchema.enumextra)
-      }; // 删除此前的enum、enumextra
-
+      };
+      // 删除此前的enum、enumextra
       delete newJSONSchema.enum;
       delete newJSONSchema.enumextra;
     }
-  } // 转换旧版的quantity类型的数据结构
-
-
+  }
+  // 转换旧版的quantity类型的数据结构
   if (newJSONSchema.format === 'quantity') {
     var curProperties = newJSONSchema.properties;
     var newQuantitySchema = objClone(TypeDataList.quantity); // 新版quantity的schema数据对象
-
     if (curProperties.quantity && isObject(curProperties.quantity) && curProperties.quantity.default) {
-      var oldDefault = curProperties.quantity.default; // percent 自动转换成 %
-
+      var oldDefault = curProperties.quantity.default;
+      // percent 自动转换成 %
       newQuantitySchema.properties.quantity.default = oldDefault === 'percent' ? '%' : oldDefault;
-    } // 融合新版schema数据
-
-
+    }
+    // 融合新版schema数据
     newJSONSchema = newQuantitySchema;
-  } // 转换旧版的datasource类型的数据结构
-
-
+  }
+  // 转换旧版的datasource类型的数据结构
   if (newJSONSchema.format === 'datasource') {
-    var _curProperties = newJSONSchema.properties; // 先获取旧版的关键数据
-
+    var _curProperties = newJSONSchema.properties;
+    // 先获取旧版的关键数据
     var typeProp = _curProperties.type && _curProperties.type.default;
     var dataProp = _curProperties.data && _curProperties.data.default;
     var filterProp = _curProperties.filter && _curProperties.filter.default;
-
     if (typeProp === 'local') {
       newJSONSchema = objClone(DataSourceTypeList.local);
       newJSONSchema.properties.data.default = dataProp ? objClone(dataProp) : '{}';
@@ -1939,22 +1845,19 @@ function oldSchemaToNewSchema(oldSchema) {
       newJSONSchema = objClone(DataSourceTypeList.remote);
       newJSONSchema.properties.data.default = dataProp ? objClone(dataProp) : 'http://xxx';
     }
-
     newJSONSchema.properties.filter.default = filterProp ? objClone(filterProp) : '() => {}';
-  } // 转换旧版的event类型的数据结构
-
-
+  }
+  // 转换旧版的event类型的数据结构
   if (newJSONSchema.format === 'event') {
-    var _curProperties2 = newJSONSchema.properties; // 先获取旧版的关键数据
-
-    var eventType = _curProperties2.type && _curProperties2.type.default; // 重构Event的数据结构
-
+    var _curProperties2 = newJSONSchema.properties;
+    // 先获取旧版的关键数据
+    var eventType = _curProperties2.type && _curProperties2.type.default;
+    // 重构Event的数据结构
     if (eventType === 'in' || eventType === 'on') {
       // 兼容旧版的'in'和新版的'on'
       // 注册类事件: 新版type改成'on'
       var eventFunc = _curProperties2.filter && _curProperties2.filter.default || '() => {}';
       newJSONSchema = objClone(EventTypeDataList.on);
-
       if (_curProperties2.actionFunc && isObject(_curProperties2.actionFunc)) {
         newJSONSchema.properties.actionFunc.default = _curProperties2.actionFunc.default || objClone(eventFunc);
       }
@@ -1962,37 +1865,30 @@ function oldSchemaToNewSchema(oldSchema) {
       // 其他，则默认为触发事件
       // 注册类事件: 新版type改成'emit'
       var _eventFunc = _curProperties2.filter && _curProperties2.filter.default || '{}';
-
       newJSONSchema = objClone(EventTypeDataList.emit);
-
       if (_curProperties2.eventData && isObject(_curProperties2.eventData)) {
         newJSONSchema.properties.eventData.default = _curProperties2.eventData.default || objClone(_eventFunc);
       }
     }
-  } // 判断是否有propertyOrder属性
-
-
+  }
+  // 判断是否有propertyOrder属性
   if (newJSONSchema.properties) {
     // 3.重新生成required属性
     newJSONSchema.required = Object.keys(newJSONSchema.properties);
-
     if (!newJSONSchema.propertyOrder) {
       // 4.生成propertyOrder属性
       newJSONSchema.propertyOrder = newJSONSchema.required;
-    } // 5.继续遍历properties属性进行转换
-
-
+    }
+    // 5.继续遍历properties属性进行转换
     newJSONSchema.propertyOrder.map(function (jsonKey) {
       newJSONSchema.properties[jsonKey] = oldSchemaToNewSchema(newJSONSchema.properties[jsonKey]);
     });
-  } // 判断是否有items属性
-
-
+  }
+  // 判断是否有items属性
   if (newJSONSchema.items) {
     // 6. 转换items中的数据
     newJSONSchema.items = oldSchemaToNewSchema(newJSONSchema.items);
   }
-
   return newJSONSchema;
 }
 
@@ -2008,20 +1904,15 @@ function oldSchemaToNewSchema(oldSchema) {
  * 根据jsonSchema和旧版的jsonData生成一份对应的jsonData
  * 备注：使用旧版数据，以便进行新旧数据融合
  * */
-
 function baseSchema2JsonData(jsonSchema, jsonData) {
   var curJsonData = '';
   var oldValue = jsonData;
-
-  if (exitPropertie(oldValue) && exitPropertie(jsonSchema.default) && typeof oldValue !== typeof jsonSchema.default) {
+  if (hasProperties(oldValue) && hasProperties(jsonSchema.default) && typeof oldValue !== typeof jsonSchema.default) {
     // 表示当前数据类型发生变化，则丢弃旧版数据
     oldValue = undefined;
   }
   /** 旧版原有数值优先使用，其次在使用schema中定义的默认值 */
-
-
-  var curValue = exitPropertie(oldValue) ? oldValue : jsonSchema.default;
-
+  var curValue = hasProperties(oldValue) ? oldValue : jsonSchema.default;
   switch (jsonSchema.type) {
     case 'string':
       if (jsonSchema.format === 'typeSelect') {
@@ -2031,14 +1922,12 @@ function baseSchema2JsonData(jsonSchema, jsonData) {
         if (curValue === '#fff' || curValue === '#FFF') {
           curValue = '#ffffff'; // 避免出现#fff类型的值，type=color不能识别
         }
-
         curJsonData = curValue || '#ffffff';
       } else if (jsonSchema.format === 'json' || jsonSchema.format === 'widget') {
         /** 转成json类型进行特殊处理
          * 需要保证json类型的数值是json对象 */
         var curJsonItemData = ''; // 字符串类型的json数据
         // 判断当前jsonData是否是对象类型
-
         if (isObject(jsonData) || isArray(jsonData)) {
           curJsonItemData = jsonData;
         } else if (isFunction(jsonData) || jsonData === '') {
@@ -2056,57 +1945,44 @@ function baseSchema2JsonData(jsonSchema, jsonData) {
             curJsonItemData = {};
           }
         }
-
         curJsonData = curJsonItemData;
       } else {
         // 其他类型允许出现空字符串
-        curJsonData = exitPropertie(curValue) ? curValue : '';
+        curJsonData = hasProperties(curValue) ? curValue : '';
       }
-
       break;
-
     case 'boolean':
-      curJsonData = exitPropertie(curValue) ? curValue : false;
+      curJsonData = hasProperties(curValue) ? curValue : false;
       break;
-
     case 'number':
-      curJsonData = exitPropertie(curValue) ? curValue : 1;
+      curJsonData = hasProperties(curValue) ? curValue : 1;
       break;
-
     default:
-      curJsonData = exitPropertie(curValue) ? curValue : '';
+      curJsonData = hasProperties(curValue) ? curValue : '';
   }
-
   return curJsonData;
 }
+
 /**
  * Object类型的schema转jsonData
  * 根据jsonSchema和旧版的jsonData生成一份对应的jsonData
  * 备注：使用旧版数据，以便进行新旧数据融合
  * */
-
-
 function objectSchema2JsonData(jsonSchema, jsonData) {
   var curJsonData = {};
   var curType = getCurrentFormat(jsonSchema);
-
   if (isObject(jsonSchema) && jsonSchema.type === 'object') {
     var jsonItem = jsonSchema;
     var oldValue = jsonData;
-
-    if (exitPropertie(oldValue) && exitPropertie(jsonItem.default) && typeof oldValue !== typeof jsonItem.default) {
+    if (hasProperties(oldValue) && hasProperties(jsonItem.default) && typeof oldValue !== typeof jsonItem.default) {
       // 表示当前数据类型发生变化，则丢弃旧版数据
       oldValue = undefined;
     }
     /** 旧版原有数值优先使用，其次在使用schema中定义的默认值 */
-
-
-    var curValue = exitPropertie(oldValue) ? oldValue : jsonItem.default;
-
+    var curValue = hasProperties(oldValue) ? oldValue : jsonItem.default;
     if (curType === 'dynamic-data') {
       // 动态数据源类型（固定格式的Object类型）
       curJsonData = objClone(EmptyDynamicDataCont);
-
       if (curValue && isObject(curValue) && JSON.stringify(curValue) !== '{}') {
         curJsonData = Object.assign(curJsonData, curValue);
       }
@@ -2117,17 +1993,15 @@ function objectSchema2JsonData(jsonSchema, jsonData) {
         curJsonData = {
           data: '{}',
           filter: '() => {}'
-        }; // 读取旧值
-
+        };
+        // 读取旧值
         if (curValue && curValue.data) {
           curJsonData.data = curValue.data;
         }
-
         if (curValue && curValue.filter) {
           curJsonData.filter = curValue.filter;
-        } // 纠正data中的默认数据
-
-
+        }
+        // 纠正data中的默认数据
         if (curJsonData.data === 'http://xxx') {
           curJsonData.data = '{}';
         }
@@ -2136,17 +2010,15 @@ function objectSchema2JsonData(jsonSchema, jsonData) {
         curJsonData = {
           data: 'http://xxx',
           filter: '() => {}'
-        }; // 读取旧值
-
+        };
+        // 读取旧值
         if (curValue && curValue.data) {
           curJsonData.data = curValue.data;
         }
-
         if (curValue && curValue.filter) {
           curJsonData.filter = curValue.filter;
-        } // 纠正data中的默认数据
-
-
+        }
+        // 纠正data中的默认数据
         if (curJsonData.data === '{}') {
           curJsonData.data = 'http://xxx';
         }
@@ -2166,12 +2038,11 @@ function objectSchema2JsonData(jsonSchema, jsonData) {
             trigger: 'eventName',
             // 兼容旧版数据
             eventData: '{}'
-          }; // 读取旧值
-
+          };
+          // 读取旧值
           if (curValue && curValue.trigger) {
             curJsonData.trigger = curValue.trigger;
           }
-
           if (curValue && curValue.eventData) {
             curJsonData.eventData = curValue.eventData;
           }
@@ -2182,19 +2053,17 @@ function objectSchema2JsonData(jsonSchema, jsonData) {
           curJsonData = {
             register: 'eventName',
             actionFunc: curValue && curValue.filter || '() => {}' // 兼容旧版数据
-
           };
         } else {
           curJsonData = {
             register: 'eventName',
             // 兼容旧版数据
             actionFunc: '() => {}'
-          }; // 读取旧值
-
+          };
+          // 读取旧值
           if (curValue && curValue.register) {
             curJsonData.register = curValue.register;
           }
-
           if (curValue && curValue.actionFunc) {
             curJsonData.actionFunc = curValue.actionFunc;
           }
@@ -2202,28 +2071,23 @@ function objectSchema2JsonData(jsonSchema, jsonData) {
       }
     } else if (jsonSchema.properties) {
       var curPropertyOrder = [];
-
       if (jsonSchema.propertyOrder) {
         curPropertyOrder = jsonSchema.propertyOrder;
       } else {
         curPropertyOrder = Object.keys(jsonSchema.properties);
-      } // 其他非固定格式的Object类型
-
-
+      }
+      // 其他非固定格式的Object类型
       curPropertyOrder.map(function (jsonKey) {
         var curJsonItem = jsonSchema.properties[jsonKey];
         var curOldValue = jsonData && jsonData[jsonKey];
-
         switch (curJsonItem.type) {
           case 'array':
             curJsonData[jsonKey] = arraySchema2JsonData(curJsonItem, curOldValue);
             break;
-
           case 'object':
             // 普通对象类型
             curJsonData[jsonKey] = objectSchema2JsonData(curJsonItem, curOldValue);
             break;
-
           default:
             // 其他基础类型
             curJsonData[jsonKey] = baseSchema2JsonData(curJsonItem, curOldValue);
@@ -2231,32 +2095,26 @@ function objectSchema2JsonData(jsonSchema, jsonData) {
       });
     }
   }
-
   return curJsonData;
 }
+
 /**
  * Array类型的schema转jsonData
  * 根据jsonSchema和旧版的jsonData生成一份对应的jsonData
  * 备注：使用旧版数据，以便进行新旧数据融合
  * */
-
-
 function arraySchema2JsonData(jsonSchema, jsonData) {
-  var curJsonData = []; // 判断是否是数组类型
-
+  var curJsonData = [];
+  // 判断是否是数组类型
   if (jsonSchema && jsonSchema.type === 'array') {
     // Array数据对象类型
     var oldValue = jsonData;
-
-    if (exitPropertie(oldValue) && exitPropertie(jsonSchema.default) && typeof oldValue !== typeof jsonSchema.default) {
+    if (hasProperties(oldValue) && hasProperties(jsonSchema.default) && typeof oldValue !== typeof jsonSchema.default) {
       // 表示当前数据类型发生变化，则丢弃旧版数据
       oldValue = undefined;
     }
     /** 旧版原有数值优先使用，其次在使用schema中定义的默认值 */
-
-
-    var curValue = exitPropertie(oldValue) ? oldValue : jsonSchema.default;
-
+    var curValue = hasProperties(oldValue) ? oldValue : jsonSchema.default;
     if (jsonSchema.format === 'array') {
       if (isArray(curValue)) {
         curValue.map(function (arrItem) {
@@ -2268,21 +2126,18 @@ function arraySchema2JsonData(jsonSchema, jsonData) {
       }
     } else {
       // 考虑select类型（多选的数值也是以array对象记录）
-      curJsonData = exitPropertie(curValue) ? curValue : [];
+      curJsonData = hasProperties(curValue) ? curValue : [];
     }
   }
-
   return curJsonData;
 }
+
 /**
  * 根据jsonSchema和旧版的jsonData生成一份对应的jsonData
  * 备注：使用旧版数据，以便进行新旧数据融合
  * */
-
-
 function schema2json(jsonSchema, jsonData) {
   var curJsonData = {};
-
   if (jsonSchema.type === 'object') {
     curJsonData = objectSchema2JsonData(jsonSchema, jsonData);
   } else if (jsonSchema.type === 'array') {
@@ -2290,7 +2145,6 @@ function schema2json(jsonSchema, jsonData) {
   } else {
     curJsonData = baseSchema2JsonData(jsonSchema, jsonData);
   }
-
   return curJsonData;
 }
 
@@ -2300,6 +2154,7 @@ function schema2json(jsonSchema, jsonData) {
  * 10个特殊类型组件（Object、Array、Json、datasource、DynamicData、Event、CodeArea、htmlArea、quantity、widget）
  */
 
+// 类型数据清单
 var schemaMetaList = TypeDataList;
 
 /**
@@ -2376,15 +2231,14 @@ var schemaMetaList = TypeDataList;
 }
  */
 function dynamicDataAnalyzer(curJsonData, analyzerResult) {
-  var curAnalyzerResult = analyzerResult || []; // 根据当前schem数据分析使用到的元数据情况
-
+  var curAnalyzerResult = analyzerResult || [];
+  // 根据当前schema数据分析使用到的元数据情况
   if (curJsonData && JSON.stringify(curJsonData) !== '{}') {
     if (isObject(curJsonData)) {
       // const curJsonMap = Object.keys(curJsonData); // 动态数据类型的jsonData包含四个数值：type、config（dataName/body/filter）、data、localFilter
       // 判断是否是动态数据类型
-      if (curJsonData.type && curJsonData.type === 'remote' && curJsonData.config && isObject(curJsonData.config) && curJsonData.config.dataName && exitPropertie(curJsonData.localFilter) && exitPropertie(curJsonData.data)) {
+      if (curJsonData.type && curJsonData.type === 'remote' && curJsonData.config && isObject(curJsonData.config) && curJsonData.config.dataName && hasProperties(curJsonData.localFilter) && hasProperties(curJsonData.data)) {
         var apiParams = curJsonData.config.body;
-
         if (apiParams && !isObject(apiParams)) {
           try {
             apiParams = JSON.parse(apiParams);
@@ -2392,7 +2246,6 @@ function dynamicDataAnalyzer(curJsonData, analyzerResult) {
             apiParams = {};
           }
         }
-
         curAnalyzerResult.push({
           id: curJsonData.config.id,
           dataName: curJsonData.config.dataName,
@@ -2410,7 +2263,6 @@ function dynamicDataAnalyzer(curJsonData, analyzerResult) {
       });
     }
   }
-
   return curAnalyzerResult;
 }
 
@@ -2444,13 +2296,12 @@ function dynamicDataAnalyzer(curJsonData, analyzerResult) {
   },
  ];
  */
+
 /**
  *  DataRoute转真实数据路径
  * */
-
 function dataRoute2dataPath(dataRoute, baseDataPath) {
   var dataPath = baseDataPath || 'data'; // 默认数据根路径值为data
-
   var dataRouteArr = dataRoute.split('-');
   dataRouteArr.map(function (path) {
     if (/^\d+$/.test(path)) {
@@ -2461,19 +2312,17 @@ function dataRoute2dataPath(dataRoute, baseDataPath) {
   });
   return dataPath;
 }
+
 /**
  *  mockData转treeData（供antd的TreeSelect使用）
  * */
-
 function json2treeData(mockData, parentDataRoute) {
   var treeData = [];
-
   if (isObject(mockData)) {
     var mockDataProps = Object.keys(mockData);
     mockDataProps.map(function (propKey) {
       var mockDataItem = mockData[propKey];
       var curDataRoute = parentDataRoute ? parentDataRoute + "-" + propKey : propKey;
-
       if (isObject(mockDataItem) || isArray(mockDataItem)) {
         treeData.push({
           title: propKey,
@@ -2493,7 +2342,6 @@ function json2treeData(mockData, parentDataRoute) {
     mockData.map(function (mockDataItem, index) {
       var indexStr = index.toString();
       var curDataRoute = parentDataRoute ? parentDataRoute + "-" + index : indexStr;
-
       if (isObject(mockDataItem) || isArray(mockDataItem)) {
         treeData.push({
           title: indexStr,
@@ -2510,7 +2358,6 @@ function json2treeData(mockData, parentDataRoute) {
       }
     });
   }
-
   return treeData;
 }
 
@@ -2522,10 +2369,10 @@ function getParentKeyRoute(curKeyRoute) {
   curKeyArr.pop();
   return curKeyArr.join('-');
 }
+
 /**
  * 获取父元素的key路径值和当前key
  */
-
 function getParentKeyRoute_CurKey(curKeyRoute) {
   var curKeyArr = curKeyRoute.split('-');
   var curKey = curKeyArr.pop();
@@ -2535,4 +2382,4 @@ function getParentKeyRoute_CurKey(curKeyRoute) {
 // JSONSchema关键字清单
 var KeyWordList = ['key', 'enum', 'enumextra', 'items', 'input', 'boolean', 'number', 'color', 'url', 'textarea', 'text-editor', 'radio', 'single-select', 'select', 'date', 'date-time', 'time', 'json', 'codearea', 'htmlarea', 'quantity', 'box-style', 'dynamic-data', 'datasource', 'event', 'array', 'object', 'widget', 'widgets', 'widgetUUID', 'embedWidgetList'];
 
-export { DataSourceTypeList, EventTypeDataList, KeyWordList, TypeDataList, dataRoute2dataPath, dynamicDataAnalyzer, exitPropertie, getCurPosition, getCurrentFormat, getJsonDataByKeyRoute, getNextIndexRoute, getParentIndexRoute, getParentIndexRoute_CurIndex, getParentKeyRoute, getParentKeyRoute_CurKey, getSchemaByIndexRoute, getSchemaByKeyRoute, indexRoute2keyRoute, isArray, isBoolean, isBoxSchemaData, isColor, isDateStr, isDateTimeStr, isEmptySchema, isEmptyWidgetSchema, isEqual, isFirstSchemaData, isFunction, isNewSchemaData, isNumber, isObject, isQuantity, isSameParent, isSelect, isString, isStructuredSchema, isTimeStr, isURL, isUsedToWidgetConfig, json2schema, json2treeData, keyRoute2indexRoute, metaElemAnalyzer, moveBackward, moveForward, objClone, oldSchemaToNewSchema, schema2json, schemaMetaList };
+export { DataSourceTypeList, EventTypeDataList, KeyWordList, TypeDataList, dataRoute2dataPath, dynamicDataAnalyzer, getCurPosition, getCurrentFormat, getJsonDataByKeyRoute, getNextIndexRoute, getParentIndexRoute, getParentIndexRoute_CurIndex, getParentKeyRoute, getParentKeyRoute_CurKey, getSchemaByIndexRoute, getSchemaByKeyRoute, hasProperties, indexRoute2keyRoute, isArray, isBoolean, isBoxSchemaData, isColor, isDateStr, isDateTimeStr, isEmptySchema, isEmptyWidgetSchema, isEqual, isFirstSchemaData, isFunction, isNewSchemaData, isNumber, isObject, isQuantity, isSameParent, isSelect, isString, isStructuredSchema, isTimeStr, isURL, isUsedToWidgetConfig, json2schema, json2treeData, keyRoute2indexRoute, metaElemAnalyzer, moveBackward, moveForward, objClone, oldSchemaToNewSchema, schema2json, schemaMetaList };