ele-admin-plus 1.2.2-beta.5 → 1.3.1-beta.1

package/es/ele-pro-form-builder/components/table-util.js

@@ -0,0 +1,617 @@
+import { eachTree } from "../../utils/core";
+import { generateUniqueItemKey, generateChildFormItem } from "../util";
+function getTableFormItemByTd(tdFormItemId, formItems) {
+  let tableFormItem;
+  let tdFormItem;
+  let trItemIndex;
+  eachTree(formItems, (item, _tdIndex, parent) => {
+    if (item.key === tdFormItemId) {
+      tdFormItem = item;
+      eachTree(formItems, (trItem, trIndex, tableItem) => {
+        if (parent && trItem.key === parent.key && tableItem) {
+          tableFormItem = tableItem;
+          trItemIndex = trIndex;
+          return false;
+        }
+      });
+      return false;
+    }
+  });
+  return { tableFormItem, tdFormItem, trItemIndex };
+}
+function getTableCellContents(tdFormItemId, formItems) {
+  let children;
+  if (tdFormItemId != null) {
+    eachTree(formItems, (item) => {
+      if (item.key === tdFormItemId) {
+        children = item.children;
+        return false;
+      }
+    });
+  }
+  return children || [];
+}
+function generateTableGrid(tableRowFormItems) {
+  var _a, _b;
+  const tableRowItems = tableRowFormItems || [];
+  const rowLength = tableRowItems.length;
+  const cellLength = Math.max(
+    0,
+    ...tableRowItems.map(
+      (rowItem) => (rowItem.children || []).map((cellItem) => {
+        var _a2;
+        return ((_a2 = cellItem.props) == null ? void 0 : _a2.colspan) ?? 1;
+      }).reduce((sum, current) => sum + current, 0)
+    )
+  );
+  const gridData = Array.from({ length: rowLength }, (_, i) => ({
+    itemId: tableRowItems[i].key,
+    children: Array.from({ length: cellLength }, () => ({
+      rowspan: 0,
+      colspan: 0
+    }))
+  }));
+  for (let i = 0; i < rowLength; i++) {
+    const tableCellItems = tableRowItems[i].children || [];
+    for (let j = 0; j < tableCellItems.length; j++) {
+      const tableCellItem = tableCellItems[j];
+      const cellRowspan = ((_a = tableCellItem.props) == null ? void 0 : _a.rowspan) ?? 1;
+      const cellColspan = ((_b = tableCellItem.props) == null ? void 0 : _b.colspan) ?? 1;
+      for (let gj = j; gj < cellLength; gj++) {
+        const gridItem = gridData[i].children[gj];
+        if (gridItem.itemId == null) {
+          gridItem.itemId = tableCellItem.key;
+          gridItem.rowspan = cellRowspan;
+          gridItem.colspan = cellColspan;
+          if (cellColspan > 1) {
+            for (let nj = gj + 1; nj < gj + cellColspan; nj++) {
+              if (nj < cellLength) {
+                gridData[i].children[nj].itemId = gridItem.itemId;
+                gridData[i].children[nj].rowspan = 1;
+              }
+            }
+          }
+          if (cellRowspan > 1) {
+            for (let ni = i + 1; ni < i + cellRowspan; ni++) {
+              if (ni < rowLength) {
+                gridData[ni].children[gj].itemId = gridItem.itemId;
+                gridData[ni].children[gj].colspan = 1;
+              }
+            }
+          }
+          if (cellColspan > 1 && cellRowspan > 1) {
+            for (let ni = i + 1; ni < i + cellRowspan; ni++) {
+              for (let nj = gj + 1; nj < gj + cellColspan; nj++) {
+                if (ni < rowLength && nj < cellLength) {
+                  gridData[ni].children[nj].itemId = gridItem.itemId;
+                }
+              }
+            }
+          }
+          break;
+        }
+      }
+    }
+  }
+  for (let i = 0; i < gridData.length; i++) {
+    for (let j = 0; j < gridData[i].children.length; j++) {
+      const gridItem = gridData[i].children[j];
+      if (gridItem.colspan === 0 || gridItem.rowspan === 0) {
+        gridItem.itemId = void 0;
+      }
+    }
+  }
+  return gridData;
+}
+function splitTableGridCell(gridData, tdFormItemId) {
+  for (let i = 0; i < gridData.length; i++) {
+    for (let j = 0; j < gridData[i].children.length; j++) {
+      const gridItem = gridData[i].children[j];
+      if (gridItem.itemId != null && gridItem.itemId === tdFormItemId) {
+        if (gridItem.colspan != null && gridItem.colspan > 1) {
+          for (let n = 1; n < gridItem.colspan; n++) {
+            const temp = gridData[i].children[j + n];
+            if (temp.oldColspan == null) {
+              temp.oldColspan = temp.colspan;
+            }
+            temp.colspan = 1;
+            temp.newColspan = temp.colspan;
+          }
+        }
+        if (gridItem.rowspan != null && gridItem.rowspan > 1) {
+          for (let n = 1; n < gridItem.rowspan; n++) {
+            const temp = gridData[i + n].children[j];
+            if (temp.oldRowspan == null) {
+              temp.oldRowspan = temp.rowspan;
+            }
+            temp.rowspan = 1;
+            temp.newRowspan = temp.rowspan;
+          }
+        }
+        if (gridItem.colspan != null && gridItem.colspan > 1 && gridItem.rowspan != null && gridItem.rowspan > 1) {
+          for (let ni = 1; ni < gridItem.rowspan; ni++) {
+            for (let nj = 1; nj < gridItem.colspan; nj++) {
+              const temp = gridData[i + ni].children[j + nj];
+              if (temp.oldColspan == null) {
+                temp.oldColspan = temp.colspan;
+              }
+              if (temp.oldRowspan == null) {
+                temp.oldRowspan = temp.rowspan;
+              }
+              temp.colspan = 1;
+              temp.rowspan = 1;
+              temp.newColspan = temp.colspan;
+              temp.newRowspan = temp.rowspan;
+            }
+          }
+        }
+        if (gridItem.oldColspan == null) {
+          gridItem.oldColspan = gridItem.colspan;
+        }
+        if (gridItem.oldRowspan == null) {
+          gridItem.oldRowspan = gridItem.rowspan;
+        }
+        gridItem.colspan = 1;
+        gridItem.rowspan = 1;
+        gridItem.newColspan = gridItem.colspan;
+        gridItem.newRowspan = gridItem.rowspan;
+        return;
+      }
+    }
+  }
+}
+function computeTableGridSpan(gridData, precorrect) {
+  if (precorrect) {
+    for (let i = 0; i < gridData.length; i++) {
+      for (let j = 0; j < gridData[i].children.length; j++) {
+        const gridItem = gridData[i].children[j];
+        if (gridItem.colspan != null && gridItem.colspan > 1) {
+          for (let n = 1; n < gridItem.colspan; n++) {
+            gridData[i].children[j + n].colspan = 0;
+            gridData[i].children[j + n].rowspan = 1;
+          }
+        }
+        if (gridItem.rowspan != null && gridItem.rowspan > 1) {
+          for (let n = 1; n < gridItem.rowspan; n++) {
+            gridData[i + n].children[j].colspan = 1;
+            gridData[i + n].children[j].rowspan = 0;
+          }
+        }
+        if (gridItem.colspan != null && gridItem.colspan > 1 && gridItem.rowspan != null && gridItem.rowspan > 1) {
+          for (let ni = 1; ni < gridItem.rowspan; ni++) {
+            for (let nj = 1; nj < gridItem.colspan; nj++) {
+              gridData[i + ni].children[j + nj].colspan = 0;
+              gridData[i + ni].children[j + nj].rowspan = 0;
+            }
+          }
+        }
+      }
+    }
+  }
+  for (let i = 0; i < gridData.length; i++) {
+    for (let j = 0; j < gridData[i].children.length; j++) {
+      const gridItem = gridData[i].children[j];
+      if (gridItem.colspan !== 0 && gridItem.rowspan !== 0) {
+        if (gridItem.oldColspan == null) {
+          gridItem.oldColspan = gridItem.colspan;
+        }
+        gridItem.colspan = 1;
+        for (let n = j + 1; n < gridData[i].children.length; n++) {
+          if (gridData[i].children[n].colspan !== 0) {
+            break;
+          }
+          gridItem.colspan++;
+        }
+        gridItem.newColspan = gridItem.colspan;
+        if (gridItem.oldRowspan == null) {
+          gridItem.oldRowspan = gridItem.rowspan;
+        }
+        gridItem.rowspan = 1;
+        for (let n = i + 1; n < gridData.length; n++) {
+          if (gridData[n].children[j].rowspan !== 0) {
+            break;
+          }
+          gridItem.rowspan++;
+        }
+        gridItem.newRowspan = gridItem.rowspan;
+      }
+    }
+  }
+}
+function deleteTableGridEmptyRow(gridData) {
+  const deleteItemIds = [];
+  for (let i = 0; i < gridData.length; i++) {
+    if (gridData[i].children.every((c) => c.colspan === 0 || c.rowspan === 0)) {
+      deleteItemIds.push(gridData[i].itemId);
+      gridData.splice(i, 1);
+      deleteTableGridEmptyRow(gridData).forEach((itemId) => {
+        deleteItemIds.push(itemId);
+      });
+      return deleteItemIds;
+    }
+  }
+  return deleteItemIds;
+}
+function deleteTableGridEmptyCol(gridData) {
+  const deleteItemIds = [];
+  const colLength = gridData.length ? gridData[0].children.length : 0;
+  for (let j = 0; j < colLength; j++) {
+    let isEmptyCol = true;
+    for (let i = 0; i < gridData.length; i++) {
+      const c = gridData[i].children[j];
+      if (!(c.colspan === 0 || c.rowspan === 0)) {
+        isEmptyCol = false;
+        break;
+      }
+    }
+    if (isEmptyCol) {
+      for (let i = 0; i < gridData.length; i++) {
+        const itemId = gridData[i].children[j].itemId;
+        if (itemId != null) {
+          deleteItemIds.push(itemId);
+        }
+        gridData[i].children.splice(j, 1);
+      }
+      deleteTableGridEmptyCol(gridData).forEach((itemId) => {
+        deleteItemIds.push(itemId);
+      });
+      return deleteItemIds;
+    }
+  }
+  return deleteItemIds;
+}
+function deleteTableGridRow(gridData, deleteRowIndex) {
+  const deleteItemIds = [];
+  gridData[deleteRowIndex].children.forEach((gridItem) => {
+    if (gridItem.itemId != null && gridItem.rowspan != null && gridItem.rowspan > 1) {
+      splitTableGridCell(gridData, gridItem.itemId);
+    }
+  });
+  const deletedItemId = gridData[deleteRowIndex].itemId;
+  gridData.splice(deleteRowIndex, 1);
+  deleteTableGridEmptyCol(gridData).forEach((itemId) => {
+    deleteItemIds.push(itemId);
+  });
+  deleteTableGridEmptyRow(gridData).forEach((itemId) => {
+    deleteItemIds.push(itemId);
+  });
+  computeTableGridSpan(gridData);
+  deleteItemIds.push(deletedItemId);
+  return deleteItemIds;
+}
+function deleteTableGridCol(gridData, deleteColIndex) {
+  const deleteItemIds = [];
+  gridData.forEach((gridRow) => {
+    const gridItem = gridRow.children[deleteColIndex];
+    if (gridItem.itemId != null && gridItem.colspan != null && gridItem.colspan > 1) {
+      splitTableGridCell(gridData, gridItem.itemId);
+    }
+  });
+  gridData.forEach((gridRow) => {
+    const gridItem = gridRow.children[deleteColIndex];
+    if (gridItem.itemId != null) {
+      deleteItemIds.push(gridItem.itemId);
+    }
+    gridRow.children.splice(deleteColIndex, 1);
+  });
+  deleteTableGridEmptyCol(gridData).forEach((itemId) => {
+    deleteItemIds.push(itemId);
+  });
+  deleteTableGridEmptyRow(gridData).forEach((itemId) => {
+    deleteItemIds.push(itemId);
+  });
+  computeTableGridSpan(gridData);
+  return deleteItemIds;
+}
+function getTableGridEffects(gridData, formItems) {
+  const addItems = [];
+  const updateItems = [];
+  const addedKeys = [];
+  gridData.forEach((gridRow) => {
+    gridRow.children.forEach((gridItem, gridItemIndex) => {
+      const rowspanChanged = gridItem.newRowspan != null && gridItem.oldRowspan != null && gridItem.newRowspan !== gridItem.oldRowspan;
+      const colspanChanged = gridItem.newColspan != null && gridItem.oldColspan != null && gridItem.newColspan !== gridItem.oldColspan;
+      if ((rowspanChanged || colspanChanged) && gridItem.itemId == null && gridItem.newRowspan !== 0 && gridItem.newColspan !== 0) {
+        const tdKey = generateUniqueItemKey(formItems, addedKeys);
+        addedKeys.push(tdKey);
+        const childTd = generateChildFormItem("tableRow", void 0, tdKey);
+        const index = gridRow.children.filter(
+          (cell, i) => i < gridItemIndex && cell.colspan !== 0 && cell.rowspan !== 0
+        ).length;
+        addItems.push({ item: childTd, parentItemId: gridRow.itemId, index });
+      }
+      if (gridItem.itemId != null && rowspanChanged) {
+        updateItems.push({
+          itemId: gridItem.itemId,
+          field: "props.rowspan",
+          value: gridItem.newRowspan
+        });
+      }
+      if (gridItem.itemId != null && colspanChanged) {
+        updateItems.push({
+          itemId: gridItem.itemId,
+          field: "props.colspan",
+          value: gridItem.newColspan
+        });
+      }
+    });
+  });
+  return { addItems, updateItems, deleteItemIds: [] };
+}
+function getTableRowInsertIndex(gridData, tdFormItem, position) {
+  const defaultIndex = position === -1 ? 0 : gridData.length;
+  if (!tdFormItem) {
+    return { insertIndex: defaultIndex };
+  }
+  for (let i = 0; i < gridData.length; i++) {
+    for (let j = 0; j < gridData[i].children.length; j++) {
+      const gridItem = gridData[i].children[j];
+      if (gridItem.itemId != null && gridItem.itemId === tdFormItem.key) {
+        if (position === -1) {
+          return {
+            trFormItemIndex: i,
+            insertIndex: i,
+            tdFormItemIndex: j
+          };
+        }
+        return {
+          trFormItemIndex: i,
+          insertIndex: i + gridItem.rowspan,
+          tdFormItemIndex: j
+        };
+      }
+    }
+  }
+  return { insertIndex: defaultIndex };
+}
+function getTableColInsertIndex(gridData, tdFormItem, position) {
+  var _a, _b;
+  const defaultIndex = position === -1 ? 0 : ((_b = (_a = gridData[0]) == null ? void 0 : _a.children) == null ? void 0 : _b.length) || 0;
+  if (!tdFormItem) {
+    return { insertIndex: defaultIndex };
+  }
+  for (let i = 0; i < gridData.length; i++) {
+    for (let j = 0; j < gridData[i].children.length; j++) {
+      const gridItem = gridData[i].children[j];
+      if (gridItem.itemId != null && gridItem.itemId === tdFormItem.key) {
+        if (position === -1) {
+          return {
+            tdFormItemIndex: j,
+            insertIndex: j,
+            trFormItemIndex: i
+          };
+        }
+        return {
+          tdFormItemIndex: j,
+          insertIndex: j + gridItem.colspan,
+          trFormItemIndex: i
+        };
+      }
+    }
+  }
+  return { insertIndex: defaultIndex };
+}
+function generateAddTableRowData(tableFormItem, formItems, tdFormItem, position) {
+  var _a;
+  const addItems = [];
+  const trKey = generateUniqueItemKey(formItems);
+  const addedKeys = [trKey];
+  const childTr = generateChildFormItem(tableFormItem.type, void 0, trKey);
+  const gridData = generateTableGrid(tableFormItem.children);
+  const { trFormItemIndex, insertIndex } = getTableRowInsertIndex(
+    gridData,
+    tdFormItem,
+    position
+  );
+  const trGridRowChilds = (gridData.length ? (_a = gridData[trFormItemIndex ?? gridData.length - 1]) == null ? void 0 : _a.children : void 0) || [{ rowspan: 1, colspan: 1 }];
+  gridData.splice(insertIndex, 0, {
+    itemId: trKey,
+    children: trGridRowChilds.map(() => ({ colspan: 1, rowspan: 1 }))
+  });
+  computeTableGridSpan(gridData, true);
+  gridData[insertIndex].children.forEach((gridItem) => {
+    if (gridItem.rowspan !== 0 && gridItem.colspan !== 0) {
+      const tdKey = generateUniqueItemKey(formItems, addedKeys);
+      addedKeys.push(tdKey);
+      const childTd = generateChildFormItem("tableRow", void 0, tdKey);
+      if (childTr.children) {
+        childTr.children.push(childTd);
+      } else {
+        childTr.children = [childTd];
+      }
+    }
+  });
+  addItems.push({
+    item: childTr,
+    parentItemId: tableFormItem.key,
+    index: insertIndex
+  });
+  return {
+    addItems,
+    updateItems: getTableGridEffects(gridData).updateItems,
+    deleteItemIds: []
+  };
+}
+function generateAddTableColData(tableFormItem, formItems, tdFormItem, position) {
+  var _a;
+  const addItems = [];
+  if (!((_a = tableFormItem.children) == null ? void 0 : _a.length)) {
+    return generateAddTableRowData(
+      tableFormItem,
+      formItems,
+      tdFormItem,
+      position
+    );
+  }
+  const gridData = generateTableGrid(tableFormItem.children);
+  const { insertIndex } = getTableColInsertIndex(
+    gridData,
+    tdFormItem,
+    position
+  );
+  const addedKeys = [];
+  gridData.forEach((gridRow) => {
+    gridRow.children.splice(insertIndex, 0, { rowspan: 1, colspan: 1 });
+  });
+  computeTableGridSpan(gridData, true);
+  gridData.forEach((gridRow) => {
+    const gridItem = gridRow.children[insertIndex];
+    if (gridItem.rowspan !== 0 && gridItem.colspan !== 0) {
+      const tdKey = generateUniqueItemKey(formItems, addedKeys);
+      addedKeys.push(tdKey);
+      const childTd = generateChildFormItem("tableRow", void 0, tdKey);
+      const index = gridRow.children.filter(
+        (cell, i) => i < insertIndex && cell.colspan !== 0 && cell.rowspan !== 0
+      ).length;
+      addItems.push({ item: childTd, parentItemId: gridRow.itemId, index });
+    }
+  });
+  return {
+    addItems,
+    updateItems: getTableGridEffects(gridData).updateItems,
+    deleteItemIds: []
+  };
+}
+function getTableSplitEffects(tableFormItem, formItems, tdFormItem) {
+  const gridData = generateTableGrid(tableFormItem.children);
+  splitTableGridCell(gridData, tdFormItem.key);
+  return getTableGridEffects(gridData, formItems);
+}
+function getTableDeleteRowEffects(tableFormItem, formItems, deleteRowIndex) {
+  const gridData = generateTableGrid(tableFormItem.children);
+  if (!gridData.length || gridData.length === 1) {
+    return {
+      addItems: [],
+      updateItems: [],
+      deleteItemIds: [tableFormItem.key]
+    };
+  }
+  const deleteItemIds = deleteTableGridRow(gridData, deleteRowIndex);
+  const result = getTableGridEffects(gridData, formItems);
+  result.deleteItemIds = deleteItemIds;
+  return result;
+}
+function getTableDeleteColEffects(tableFormItem, formItems, tdFormItem) {
+  const gridData = generateTableGrid(tableFormItem.children);
+  if (!gridData.length || !gridData[0].children.length || gridData[0].children.length === 1) {
+    return {
+      addItems: [],
+      updateItems: [],
+      deleteItemIds: [tableFormItem.key]
+    };
+  }
+  const deleteColIndex = getTableColInsertIndex(
+    gridData,
+    tdFormItem
+  ).tdFormItemIndex;
+  if (deleteColIndex == null) {
+    return { addItems: [], updateItems: [], deleteItemIds: [] };
+  }
+  const deleteItemIds = deleteTableGridCol(gridData, deleteColIndex);
+  const result = getTableGridEffects(gridData, formItems);
+  result.deleteItemIds = deleteItemIds;
+  return result;
+}
+function getTableMergeRightEffects(tableFormItem, formItems, tdFormItem) {
+  var _a, _b, _c, _d;
+  const gridData = generateTableGrid(tableFormItem.children);
+  const { tdFormItemIndex, insertIndex, trFormItemIndex } = getTableColInsertIndex(gridData, tdFormItem);
+  if (tdFormItemIndex == null || trFormItemIndex == null || insertIndex === tdFormItemIndex) {
+    return { addItems: [], updateItems: [], deleteItemIds: [] };
+  }
+  const gridItem = (_b = (_a = gridData[trFormItemIndex]) == null ? void 0 : _a.children) == null ? void 0 : _b[tdFormItemIndex];
+  const targetGridItem = (_d = (_c = gridData[trFormItemIndex]) == null ? void 0 : _c.children) == null ? void 0 : _d[insertIndex];
+  if (!gridItem || !targetGridItem || gridItem.rowspan !== targetGridItem.rowspan) {
+    return { addItems: [], updateItems: [], deleteItemIds: [] };
+  }
+  const deleteItemIds = [];
+  const targetChildren = getTableCellContents(targetGridItem.itemId, formItems);
+  gridItem.oldColspan = gridItem.colspan;
+  gridItem.colspan += targetGridItem.colspan;
+  gridItem.newColspan = gridItem.colspan;
+  targetGridItem.oldColspan = targetGridItem.colspan;
+  targetGridItem.colspan = 0;
+  targetGridItem.newColspan = targetGridItem.colspan;
+  if (targetGridItem.itemId != null) {
+    deleteItemIds.push(targetGridItem.itemId);
+    targetGridItem.itemId = void 0;
+  }
+  deleteTableGridEmptyCol(gridData).forEach((itemId) => {
+    deleteItemIds.push(itemId);
+  });
+  deleteTableGridEmptyRow(gridData).forEach((itemId) => {
+    deleteItemIds.push(itemId);
+  });
+  computeTableGridSpan(gridData);
+  const result = getTableGridEffects(gridData, formItems);
+  result.deleteItemIds = deleteItemIds;
+  targetChildren.forEach((child) => {
+    result.addItems.push({
+      item: child,
+      parentItemId: gridItem.itemId
+    });
+  });
+  return result;
+}
+function getTableMergeBelowEffects(tableFormItem, formItems, tdFormItem) {
+  var _a, _b, _c, _d;
+  const gridData = generateTableGrid(tableFormItem.children);
+  const { tdFormItemIndex, insertIndex, trFormItemIndex } = getTableRowInsertIndex(gridData, tdFormItem);
+  if (tdFormItemIndex == null || trFormItemIndex == null || insertIndex === trFormItemIndex) {
+    return { addItems: [], updateItems: [], deleteItemIds: [] };
+  }
+  const gridItem = (_b = (_a = gridData[trFormItemIndex]) == null ? void 0 : _a.children) == null ? void 0 : _b[tdFormItemIndex];
+  const targetGridItem = (_d = (_c = gridData[insertIndex]) == null ? void 0 : _c.children) == null ? void 0 : _d[tdFormItemIndex];
+  if (!gridItem || !targetGridItem || gridItem.colspan !== targetGridItem.colspan) {
+    return { addItems: [], updateItems: [], deleteItemIds: [] };
+  }
+  const deleteItemIds = [];
+  const targetChildren = getTableCellContents(targetGridItem.itemId, formItems);
+  gridItem.oldRowspan = gridItem.rowspan;
+  gridItem.rowspan += targetGridItem.rowspan;
+  gridItem.newRowspan = gridItem.rowspan;
+  targetGridItem.oldRowspan = targetGridItem.rowspan;
+  targetGridItem.rowspan = 0;
+  targetGridItem.newRowspan = targetGridItem.rowspan;
+  if (targetGridItem.itemId != null) {
+    deleteItemIds.push(targetGridItem.itemId);
+    targetGridItem.itemId = void 0;
+  }
+  deleteTableGridEmptyCol(gridData).forEach((itemId) => {
+    deleteItemIds.push(itemId);
+  });
+  deleteTableGridEmptyRow(gridData).forEach((itemId) => {
+    deleteItemIds.push(itemId);
+  });
+  computeTableGridSpan(gridData);
+  const result = getTableGridEffects(gridData, formItems);
+  result.deleteItemIds = deleteItemIds;
+  targetChildren.forEach((child) => {
+    result.addItems.push({
+      item: child,
+      parentItemId: gridItem.itemId
+    });
+  });
+  return result;
+}
+export {
+  computeTableGridSpan,
+  deleteTableGridCol,
+  deleteTableGridEmptyCol,
+  deleteTableGridEmptyRow,
+  deleteTableGridRow,
+  generateAddTableColData,
+  generateAddTableRowData,
+  generateTableGrid,
+  getTableCellContents,
+  getTableColInsertIndex,
+  getTableDeleteColEffects,
+  getTableDeleteRowEffects,
+  getTableFormItemByTd,
+  getTableGridEffects,
+  getTableMergeBelowEffects,
+  getTableMergeRightEffects,
+  getTableRowInsertIndex,
+  getTableSplitEffects,
+  splitTableGridCell
+};

package/es/ele-pro-form-builder/components/template-list.d.ts

@@ -0,0 +1,23 @@
+import { TemplateItem, TemplateFormConfig } from '../types';
+
+declare const _default: import('vue').DefineComponent<__VLS_TypePropsToRuntimeProps<{
+    /** 模板数据 */
+    templateData?: TemplateItem[];
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    importData: (data: TemplateFormConfig) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToRuntimeProps<{
+    /** 模板数据 */
+    templateData?: TemplateItem[];
+}>>> & {
+    onImportData?: ((data: TemplateFormConfig) => any) | undefined;
+}, {}, {}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};

package/es/ele-pro-form-builder/components/template-list.js

@@ -0,0 +1,52 @@
+import { defineComponent, openBlock, createElementBlock, Fragment, renderList, createElementVNode, toDisplayString, createBlock, resolveDynamicComponent, mergeProps, createCommentVNode, unref } from "vue";
+import { ElEmpty } from "element-plus";
+import { itemsGenerateNewKey } from "./build-util";
+const _hoisted_1 = { class: "ele-pro-form-builder-template-wrapper" };
+const _hoisted_2 = ["onClick"];
+const _hoisted_3 = { class: "ele-pro-form-builder-template-item-label" };
+const _hoisted_4 = { class: "ele-pro-form-builder-template-item-body" };
+const _hoisted_5 = { class: "ele-pro-form-builder-template-item-cover" };
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "template-list",
+  props: {
+    templateData: {}
+  },
+  emits: ["importData"],
+  setup(__props, { emit: __emit }) {
+    const emit = __emit;
+    const handleImportTemplate = (item) => {
+      const result = JSON.parse(JSON.stringify(item.config));
+      itemsGenerateNewKey(result.items, [], false);
+      emit("importData", result);
+    };
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", _hoisted_1, [
+        _ctx.templateData ? (openBlock(true), createElementBlock(Fragment, { key: 0 }, renderList(_ctx.templateData, (item) => {
+          return openBlock(), createElementBlock("div", {
+            key: item.name,
+            class: "ele-pro-form-builder-template-item",
+            onClick: ($event) => handleImportTemplate(item)
+          }, [
+            createElementVNode("div", _hoisted_3, toDisplayString(item.name), 1),
+            createElementVNode("div", _hoisted_4, [
+              createElementVNode("div", _hoisted_5, [
+                item.cover ? (openBlock(), createBlock(resolveDynamicComponent(item.cover), mergeProps({
+                  key: 0,
+                  ref_for: true
+                }, item.coverProps || {}), null, 16)) : createCommentVNode("", true)
+              ])
+            ])
+          ], 8, _hoisted_2);
+        }), 128)) : createCommentVNode("", true),
+        !_ctx.templateData || !_ctx.templateData.length ? (openBlock(), createBlock(unref(ElEmpty), {
+          key: 1,
+          imageSize: 58,
+          class: "ele-pro-form-builder-form-empty"
+        })) : createCommentVNode("", true)
+      ]);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};