@hzab/form-render 1.7.16-alpha.0 → 1.7.16

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hzab/form-render",
-  "version": "1.7.16-alpha.0",
+  "version": "1.7.16",
   "description": "",
   "main": "src",
   "scripts": {

package/src/components/LocationPicker/components/MapSearch/index.jsx

@@ -1,57 +1,57 @@
-import { useState } from "react";
-import { Input, AutoComplete } from "antd";
-
-import { getSearchTips } from "../../servers";
-
-import "./index.less";
-
-const cityCode = "0571";
-
-function Search(props) {
-  const [loading, setLoading] = useState(false);
-  const [tips, setTips] = useState([]);
-
-  function onSelect(value, option) {
-    const { lng: _lng, lat: _lat } = option || {};
-    props.setPoint && props.setPoint(_lng, _lat, { changeCenter: true });
-  }
-
-  function onSearch(search) {
-    if (!search) {
-      setTips([]);
-      return;
-    }
-    setLoading(true);
-    getSearchTips(search, props.cityCode || cityCode)
-      .then((res) => {
-        setTips(
-          res?.map((it) => ({
-            ...it,
-            label: it.name,
-            // 解决回显为 id 的问题
-            value: it.name,
-          })),
-        );
-        setLoading(false);
-      })
-      .catch((err) => {
-        setLoading(false);
-      });
-  }
-
-  return (
-    <AutoComplete
-      className="location-map-search"
-      options={tips}
-      onSelect={onSelect}
-      onSearch={_.debounce(onSearch, 500)}
-      onClear={() => {
-        setTips([]);
-      }}
-    >
-      <Input.Search allowClear loading={loading} placeholder="请输入" />
-    </AutoComplete>
-  );
-}
-
-export default Search;
+import { useState } from "react";
+import { Input, AutoComplete } from "antd";
+
+import { getSearchTips } from "../../servers";
+
+import "./index.less";
+
+const cityCode = "0571";
+
+function Search(props) {
+  const [loading, setLoading] = useState(false);
+  const [tips, setTips] = useState([]);
+
+  function onSelect(value, option) {
+    const { lng: _lng, lat: _lat } = option || {};
+    props.setPoint && props.setPoint(_lng, _lat, { changeCenter: true });
+  }
+
+  function onSearch(search) {
+    if (!search) {
+      setTips([]);
+      return;
+    }
+    setLoading(true);
+    getSearchTips(search, props.cityCode || cityCode)
+      .then((res) => {
+        setTips(
+          res?.map((it) => ({
+            ...it,
+            label: it.name,
+            // 解决回显为 id 的问题
+            value: it.name,
+          })),
+        );
+        setLoading(false);
+      })
+      .catch((err) => {
+        setLoading(false);
+      });
+  }
+
+  return (
+    <AutoComplete
+      className="location-map-search"
+      options={tips}
+      onSelect={onSelect}
+      onSearch={_.debounce(onSearch, 500)}
+      onClear={() => {
+        setTips([]);
+      }}
+    >
+      <Input.Search allowClear loading={loading} placeholder="请输入" />
+    </AutoComplete>
+  );
+}
+
+export default Search;

package/src/components/TreeCheckbox/common/utils.ts

@@ -1,221 +1,221 @@
-import _ from "lodash";
-
-export interface ITabTableDataOpt extends optT {
-  /**
-   * 展示 tab 的层级
-   */
-  tabLevel?: number;
-  /**
-   * 当前处理的层级
-   */
-  _level?: number;
-  fieldNames?: {
-    label?: string;
-    value?: string;
-    children?: string;
-  };
-}
-/**
- * 处理数据，按需设置 tab、table 数据
- * @param treeData 树数据数组
- * @param opt 配置项
- * @returns
- */
-export function getTabTableData(_treeData = [], opt: ITabTableDataOpt = {}) {
-  const treeData = _.cloneDeep(_treeData);
-  const { tabLevel = 0, _level = 0, fieldNames } = opt || {};
-  const { value, children } = fieldNames || {};
-  let resList = [];
-  // 当前层级小于 tabLevel，视为当前层级渲染为 tab
-  const isTab = _level < tabLevel;
-
-  // 当前层级渲染为 tab，直接 push 到 resList 中
-  if (isTab) {
-    resList.push({
-      level: _level,
-      defaultActiveKey: treeData[0]?.[value],
-      tabList: treeData,
-    });
-    // 继续处理子集数据
-    treeData?.forEach((it) => {
-      if (it[children]?.length > 0) {
-        it[children] = getTabTableData(it[children], {
-          ...opt,
-          _level: _level + 1,
-        });
-      }
-    });
-  } else {
-    // 非 tab 层级，处理 table 渲染数据（handleTreeToArray 自动处理子集）
-    resList.push({
-      level: _level,
-      tableData: handleTreeToArray(treeData, {
-        ...opt,
-        level: undefined,
-      }),
-    });
-  }
-  return resList;
-}
-
-/**
- * 处理树形数据，把树形数据方向转为多维数组，便于渲染
- * @param params
- * @returns
-    如：
-    [{key:1, children:[{key:11},{key:12}]}, {key:2, children:[{key:21, children:[{key:211}]},{key:22},{key:23}]}]
-    结果数组：
-      [1, 11,    ]
-      [ , 12,    ]
-      [2, 21, 211]
-      [ , 22,    ]
-      [ , 23,    ]
- */
-export function handleTreeToArray(treeData = [], opt: any = {}) {
-  const { resList, maxCol } = transformTreeData(treeData, opt);
-  resList?.forEach((row) => {
-    fillArrByPush(maxCol, row);
-  });
-  return resList;
-}
-
-export type optT = {
-  resList?: Array<any>;
-  preCol?: number;
-  //是否合并叶子节点
-  mergeLeaf?: boolean;
-  // 最后一列是否合并到一个单元格
-  mergeFullLeaf?: boolean;
-  // 当前递归的层级
-  level?: number;
-  fieldNames?: {
-    value?: string;
-    label?: string;
-    children?: string;
-  };
-};
-
-/**
- * 处理树形数据，把树形数据方向转为多维数组，便于渲染
- * @param params
- * @returns
-    如：
-    [{key:1, children:[{key:11},{key:12}]}, {key:2, children:[{key:21, children:[{key:211}]},{key:22},{key:23}]}]
-    结果数组：
-      [1, 11,    ]
-      [ , 12,    ]
-      [2, 21, 211]
-      [ , 22,    ]
-      [ , 23,    ]
- */
-export function transformTreeData(treeData = [], opt: optT = {}) {
-  const { resList = [], preCol = 0, mergeLeaf, mergeFullLeaf, level = 0, fieldNames } = opt || {};
-  const { value = "value", children = "children", label = "label" } = fieldNames || {};
-  let maxCol = preCol + 1;
-  // 统计当前项包含的最大行数（当前项的行数等于所有子项行数之和），用于合并行的值
-  let maxRow = 0;
-
-  const leafIndexList = [];
-  const leafItemList = [];
-
-  // 是否有子项
-  let hasChildren = false;
-  treeData?.forEach((it, i) => {
-    if (it && Array.isArray(it[children]) && it[children].length > 0) {
-      hasChildren = true;
-    } else {
-      // 保存当前层级的叶子节点，用于叶子节点合并
-      leafIndexList.push(i);
-      leafItemList.push(it);
-    }
-  });
-
-  let lastRowIdx = resList.length > 0 ? resList.length - 1 : 0;
-  // 合并不存在 children 的层级，mergeFullLeaf === true && hasChildren === false && level > 0 时，合并当前数据
-  if (mergeFullLeaf === true && !hasChildren && level > 0) {
-    resList[lastRowIdx].push([...treeData?.map((it) => ({ ...it, label: it[label], value: it[value] }))]);
-    return {
-      resList,
-      maxCol,
-      // 合并之后视为 1 行
-      maxRow: 1,
-    };
-  }
-
-  // 合并当前层级的叶子节点，非叶子节点忽略
-  if (mergeLeaf === true && leafIndexList.length > 0) {
-    // treeData 中删除当前层级其他叶子节点
-    for (let i = leafIndexList.length - 1; i >= 0; i--) {
-      const idx = leafIndexList[i];
-      treeData.splice(idx, 1);
-    }
-    // 所有叶子节点放在尾部
-    treeData.push({
-      _type_: "leafList",
-      leafList: leafItemList?.map((it) => ({ ...it, label: it[label], value: it[value] })),
-    });
-  }
-
-  treeData?.forEach((it, i) => {
-    let item = null;
-    if (it._type_ === "leafList") {
-      // 合并当前层级的叶子节点
-      item = it.leafList;
-    } else {
-      item = { ...it, value: it[value], label: it[label] };
-    }
-    const childList = item[children] || [];
-    const childLen = childList?.length;
-    // 当 mergeFullLeaf !== true && children 长度大于1时，子项下标大于 0 的项需要另起一行，同时补充之前空的列。
-    if (i > 0) {
-      resList.push(fillArrByPush(preCol, [], { content: false }));
-    }
-    lastRowIdx = resList.length > 0 ? resList.length - 1 : 0;
-    // 解决首次进来第一行数组空的问题
-    if (!resList[lastRowIdx]) {
-      resList[lastRowIdx] = [];
-    }
-    resList[lastRowIdx].push(item);
-    if (childLen > 0) {
-      const res = transformTreeData(childList, {
-        ...opt,
-        resList,
-        preCol: preCol + 1,
-        level: level + 1,
-      });
-      if (maxCol < res.maxCol) {
-        maxCol = res.maxCol;
-      }
-      // 当前的最大行数加上子项的行数
-      maxRow = maxRow + res.maxRow;
-      // 每项的最大行数为子项的最大行数之和
-      item._maxRow = res.maxRow;
-    } else {
-      item._maxRow = 1;
-      maxRow += 1;
-    }
-  });
-
-  return {
-    resList,
-    maxCol,
-    maxRow,
-  };
-}
-
-/**
- * 填充数组
- * @param len
- * @param arr
- * @param opt
- * @returns
- */
-export function fillArrByPush(len, arr = [], opt: any = {}) {
-  const { content } = opt || {};
-  if (arr.length < len) {
-    for (let i = arr.length; i < len; i++) {
-      arr.push(content);
-    }
-  }
-  return arr;
-}
+import _ from "lodash";
+
+export interface ITabTableDataOpt extends optT {
+  /**
+   * 展示 tab 的层级
+   */
+  tabLevel?: number;
+  /**
+   * 当前处理的层级
+   */
+  _level?: number;
+  fieldNames?: {
+    label?: string;
+    value?: string;
+    children?: string;
+  };
+}
+/**
+ * 处理数据，按需设置 tab、table 数据
+ * @param treeData 树数据数组
+ * @param opt 配置项
+ * @returns
+ */
+export function getTabTableData(_treeData = [], opt: ITabTableDataOpt = {}) {
+  const treeData = _.cloneDeep(_treeData);
+  const { tabLevel = 0, _level = 0, fieldNames } = opt || {};
+  const { value, children } = fieldNames || {};
+  let resList = [];
+  // 当前层级小于 tabLevel，视为当前层级渲染为 tab
+  const isTab = _level < tabLevel;
+
+  // 当前层级渲染为 tab，直接 push 到 resList 中
+  if (isTab) {
+    resList.push({
+      level: _level,
+      defaultActiveKey: treeData[0]?.[value],
+      tabList: treeData,
+    });
+    // 继续处理子集数据
+    treeData?.forEach((it) => {
+      if (it[children]?.length > 0) {
+        it[children] = getTabTableData(it[children], {
+          ...opt,
+          _level: _level + 1,
+        });
+      }
+    });
+  } else {
+    // 非 tab 层级，处理 table 渲染数据（handleTreeToArray 自动处理子集）
+    resList.push({
+      level: _level,
+      tableData: handleTreeToArray(treeData, {
+        ...opt,
+        level: undefined,
+      }),
+    });
+  }
+  return resList;
+}
+
+/**
+ * 处理树形数据，把树形数据方向转为多维数组，便于渲染
+ * @param params
+ * @returns
+    如：
+    [{key:1, children:[{key:11},{key:12}]}, {key:2, children:[{key:21, children:[{key:211}]},{key:22},{key:23}]}]
+    结果数组：
+      [1, 11,    ]
+      [ , 12,    ]
+      [2, 21, 211]
+      [ , 22,    ]
+      [ , 23,    ]
+ */
+export function handleTreeToArray(treeData = [], opt: any = {}) {
+  const { resList, maxCol } = transformTreeData(treeData, opt);
+  resList?.forEach((row) => {
+    fillArrByPush(maxCol, row);
+  });
+  return resList;
+}
+
+export type optT = {
+  resList?: Array<any>;
+  preCol?: number;
+  //是否合并叶子节点
+  mergeLeaf?: boolean;
+  // 最后一列是否合并到一个单元格
+  mergeFullLeaf?: boolean;
+  // 当前递归的层级
+  level?: number;
+  fieldNames?: {
+    value?: string;
+    label?: string;
+    children?: string;
+  };
+};
+
+/**
+ * 处理树形数据，把树形数据方向转为多维数组，便于渲染
+ * @param params
+ * @returns
+    如：
+    [{key:1, children:[{key:11},{key:12}]}, {key:2, children:[{key:21, children:[{key:211}]},{key:22},{key:23}]}]
+    结果数组：
+      [1, 11,    ]
+      [ , 12,    ]
+      [2, 21, 211]
+      [ , 22,    ]
+      [ , 23,    ]
+ */
+export function transformTreeData(treeData = [], opt: optT = {}) {
+  const { resList = [], preCol = 0, mergeLeaf, mergeFullLeaf, level = 0, fieldNames } = opt || {};
+  const { value = "value", children = "children", label = "label" } = fieldNames || {};
+  let maxCol = preCol + 1;
+  // 统计当前项包含的最大行数（当前项的行数等于所有子项行数之和），用于合并行的值
+  let maxRow = 0;
+
+  const leafIndexList = [];
+  const leafItemList = [];
+
+  // 是否有子项
+  let hasChildren = false;
+  treeData?.forEach((it, i) => {
+    if (it && Array.isArray(it[children]) && it[children].length > 0) {
+      hasChildren = true;
+    } else {
+      // 保存当前层级的叶子节点，用于叶子节点合并
+      leafIndexList.push(i);
+      leafItemList.push(it);
+    }
+  });
+
+  let lastRowIdx = resList.length > 0 ? resList.length - 1 : 0;
+  // 合并不存在 children 的层级，mergeFullLeaf === true && hasChildren === false && level > 0 时，合并当前数据
+  if (mergeFullLeaf === true && !hasChildren && level > 0) {
+    resList[lastRowIdx].push([...treeData?.map((it) => ({ ...it, label: it[label], value: it[value] }))]);
+    return {
+      resList,
+      maxCol,
+      // 合并之后视为 1 行
+      maxRow: 1,
+    };
+  }
+
+  // 合并当前层级的叶子节点，非叶子节点忽略
+  if (mergeLeaf === true && leafIndexList.length > 0) {
+    // treeData 中删除当前层级其他叶子节点
+    for (let i = leafIndexList.length - 1; i >= 0; i--) {
+      const idx = leafIndexList[i];
+      treeData.splice(idx, 1);
+    }
+    // 所有叶子节点放在尾部
+    treeData.push({
+      _type_: "leafList",
+      leafList: leafItemList?.map((it) => ({ ...it, label: it[label], value: it[value] })),
+    });
+  }
+
+  treeData?.forEach((it, i) => {
+    let item = null;
+    if (it._type_ === "leafList") {
+      // 合并当前层级的叶子节点
+      item = it.leafList;
+    } else {
+      item = { ...it, value: it[value], label: it[label] };
+    }
+    const childList = item[children] || [];
+    const childLen = childList?.length;
+    // 当 mergeFullLeaf !== true && children 长度大于1时，子项下标大于 0 的项需要另起一行，同时补充之前空的列。
+    if (i > 0) {
+      resList.push(fillArrByPush(preCol, [], { content: false }));
+    }
+    lastRowIdx = resList.length > 0 ? resList.length - 1 : 0;
+    // 解决首次进来第一行数组空的问题
+    if (!resList[lastRowIdx]) {
+      resList[lastRowIdx] = [];
+    }
+    resList[lastRowIdx].push(item);
+    if (childLen > 0) {
+      const res = transformTreeData(childList, {
+        ...opt,
+        resList,
+        preCol: preCol + 1,
+        level: level + 1,
+      });
+      if (maxCol < res.maxCol) {
+        maxCol = res.maxCol;
+      }
+      // 当前的最大行数加上子项的行数
+      maxRow = maxRow + res.maxRow;
+      // 每项的最大行数为子项的最大行数之和
+      item._maxRow = res.maxRow;
+    } else {
+      item._maxRow = 1;
+      maxRow += 1;
+    }
+  });
+
+  return {
+    resList,
+    maxCol,
+    maxRow,
+  };
+}
+
+/**
+ * 填充数组
+ * @param len
+ * @param arr
+ * @param opt
+ * @returns
+ */
+export function fillArrByPush(len, arr = [], opt: any = {}) {
+  const { content } = opt || {};
+  if (arr.length < len) {
+    for (let i = arr.length; i < len; i++) {
+      arr.push(content);
+    }
+  }
+  return arr;
+}