rapid-spreadjs 1.0.144 → 1.0.145

package/dist/index.cjs.js

@@ -1377,6 +1377,231 @@ const BusinessUtils = {
      * @returns 返回所有需要显示和隐藏的行索引结果对象，格式如：{hasValueIndex: [1, 2, 3], noValueIndex: [4, 5, 6]}，hasValueIndex代表所有显示的行索引，noValueIndex代表所有隐藏的行索引
      */
     dynamicLoadRows: (GC, spread, dynamicLoadRangeJson, headerRangeHeight, footerRangeHeight, remainingHeight = 500, pageDir = 1, blankRowCellValue = '空白') => {
+        const sheet = spread.getActiveSheet();
+        // 暂停绘制
+        sheet.suspendPaint();
+        // 获取所有单元格对象
+        const cells = SheetUtils.getAllCellObjsByRanges(sheet, dynamicLoadRangeJson);
+        // 设置所有行可见，原因是：如果再次执行的时候，第一次隐藏的行没有还原
+        cells.forEach((item, index) => {
+            sheet.setRowVisible(item.row, true);
+        });
+        // 获取按照row分组后的数据，格式如：{"1":[{row: 1, col: 43, rowCount: 1, colCount: 24}]}
+        const cellsGroupByRow = rapidUtils.groupByJson(cells, 'row');
+        // 获取序号列的跨列数
+        let seqColSpanCount = null;
+        // 最终行索引Key对应的单元格对象集合（跨行的索引）
+        let rowCells = [];
+        rapidUtils.forEachJson(cellsGroupByRow, (cellItems, rowIndexKey, source) => {
+            if (seqColSpanCount == null) {
+                const seqSpans = sheet.getSpans(sheet.getCell(parseInt(rowIndexKey), 1));
+                seqColSpanCount = seqSpans[0].colCount;
+            }
+            // 得到序号列的跨行单元格对象
+            const seqColSpanObj = sheet.getSpans({ row: parseInt(rowIndexKey), col: 1, rowCount: cellItems[0].rowCount, colCount: seqColSpanCount })[0];
+            // 当前序号跨行单元格对应的所有单元格中是否有值
+            let curRowHasValue = false;
+            // 当前所有行索引
+            let curRowIndexs = [];
+            for (let i = 0; i < cellItems.length; i++) {
+                // 获取当前单元格对象
+                const cell = cellItems[i];
+                for (let j = cell.row; j < cell.row + cell.rowCount; j++) {
+                    if (!curRowIndexs.some((x) => x == j)) {
+                        curRowIndexs.push(j);
+                    }
+                }
+                // 获取当前单元格的值
+                const cellValue = sheet.getValue(cell.row, cell.col);
+                // 验证是否有值
+                if (cellValue !== null &&
+                    cellValue !== undefined &&
+                    cellValue !== '' &&
+                    cellValue !== '/' &&
+                    !(cellValue instanceof GC.Spread.CalcEngine.CalcError)) {
+                    curRowHasValue = true;
+                    break;
+                }
+            }
+            let rowObjs = { row: parseInt(rowIndexKey), rows: curRowIndexs, cells: cellItems, hasValue: curRowHasValue };
+            if (!rowCells.some((x) => x.rowSpan == seqColSpanObj.row)) {
+                let rowIndexs = [];
+                const seqColSpanRowSpan = sheet.getSpans({ row: seqColSpanObj.row, col: 1, rowCount: 1, colCount: 1 })[0];
+                for (let i = 0; i < seqColSpanRowSpan.rowCount; i++) {
+                    rowIndexs.push(seqColSpanObj.row + i);
+                }
+                rowCells.push({
+                    rowSpan: seqColSpanObj.row,
+                    rowIndexs: rowIndexs,
+                    rows: [rowObjs],
+                });
+            }
+            else {
+                let curRow = rowCells.find((x) => x.rowSpan == seqColSpanObj.row);
+                curRow.rows.push(rowObjs);
+            }
+        });
+        // 有值和没有值的行索引集合
+        let hasValueRows = [], noValueRows = [];
+        // 有值的行索引（序号列使用）
+        let hasValueRowsSer = [];
+        rowCells.forEach((rowObj, index) => {
+            if (rowObj.rows.some((x) => x.hasValue) && !hasValueRowsSer.some((x) => x == rowObj.rowSpan)) {
+                hasValueRowsSer.push(rowObj.rowSpan);
+            }
+            if (rowObj.rows.some((x) => x.hasValue)) {
+                // rowObj.rows.forEach(x => {
+                //   x.rows.forEach(rowIndex => {
+                //     if (!hasValueRows.some(hItem => hItem == rowIndex)) {
+                //       hasValueRows.push(rowIndex);
+                //     }
+                //   });
+                // });
+                rowObj.rowIndexs.forEach((rowIndex) => {
+                    if (!hasValueRows.some((hItem) => hItem == rowIndex)) {
+                        hasValueRows.push(rowIndex);
+                    }
+                });
+            }
+            else {
+                // rowObj.rows.forEach(x => {
+                //   x.rows.forEach(rowIndex => {
+                //     if (!noValueRows.some(hItem => hItem == rowIndex)) {
+                //       noValueRows.push(rowIndex);
+                //     }
+                //   });
+                // });
+                rowObj.rowIndexs.forEach((rowIndex) => {
+                    if (!noValueRows.some((hItem) => hItem == rowIndex)) {
+                        noValueRows.push(rowIndex);
+                    }
+                });
+            }
+        });
+        let serNum = 0;
+        hasValueRowsSer.forEach((rowIndex, index) => {
+            const curVal = sheet.getValue(rowIndex, 1);
+            // 检查第一个单元格的值是否包含非数字字符，有非数字字符的时候代表不填充序号
+            if (!/^(?!\d+$)[\u4e00-\u9fa5a-zA-Z0-9!@#$%^&*()_+[\]{};':",.\/?\\|-]+$/.test(curVal)) {
+                serNum++;
+                // 设置序号列单元格的值（1、2、3...的格式）
+                sheet.setValue(rowIndex, 1, serNum);
+            }
+        });
+        hasValueRows.forEach((rowIndex, index) => {
+            // 设置行可见
+            sheet.setRowVisible(rowIndex, true);
+        });
+        noValueRows.forEach((rowIndex) => {
+            // 设置行不可见
+            sheet.setRowVisible(rowIndex, false);
+        });
+        /** 创建空白行单元格 */
+        const createBlackRowCell = () => {
+            // 工作表总高度
+            const sheetTotalHeight = pageDir == 1 ? 1055 : 615;
+            // 之前已经创建的空白行索引
+            let createBlackRowIndex = -1;
+            // 获取所有可见行的总高度
+            let allRowHeight = 0;
+            for (let i = 0; i < sheet.getRowCount(); i++) {
+                const curRowVisible = sheet.getRowVisible(i);
+                const blankRowCell = sheet.getTag(i, 1);
+                if (curRowVisible && (blankRowCell == null || blankRowCell == undefined || blankRowCell != 'BlankCell')) {
+                    allRowHeight += sheet.getRowHeight(i);
+                }
+                // 设置已创建的空白行索引
+                if (blankRowCell == 'BlankCell') {
+                    createBlackRowIndex = i;
+                }
+            }
+            // 针对纵表情况，工作表总高度-表头和表尾总高度>=remainingHeight，空白行不显示；<remainingHeight，空白行显示
+            // 是否显示空白行
+            let isShowBlankRow = true;
+            if (pageDir == 1 && allRowHeight - headerRangeHeight - footerRangeHeight >= remainingHeight) {
+                isShowBlankRow = false;
+            }
+            if (!isShowBlankRow) {
+                // 设置行不可见
+                if (createBlackRowIndex != -1) {
+                    sheet.setRowVisible(createBlackRowIndex, false);
+                }
+                return;
+            }
+            // 获取到最后一行动态加载区域的行索引
+            const lastRowIndex = rowCells[rowCells.length - 1].rowSpan +
+                sheet.getSpans({ row: rowCells[rowCells.length - 1].rowSpan, col: 1, rowCount: 1, colCount: 1 })[0].rowCount -
+                1; // dynamicLoadRangeJson[0].row + dynamicLoadRangeJson[0].rowCount - 1;
+            // 创建空白行
+            if (allRowHeight < sheetTotalHeight) {
+                // 获取空白行单元格的标签
+                const blankRowCell = sheet.getTag(lastRowIndex + 1, 1);
+                if (!blankRowCell || blankRowCell !== 'BlankCell') {
+                    // 添加一行、合并单元格
+                    sheet.addRows(lastRowIndex + 1, 1);
+                    sheet.addSpan(lastRowIndex + 1, 1, 1, 77);
+                    // 设置添加这一行的行高
+                    sheet.setRowHeight(lastRowIndex + 1, sheetTotalHeight - allRowHeight);
+                    // 获取添加这一行的区域范围
+                    const addRowRange = sheet.getRange(lastRowIndex + 1, 1, 1, 77);
+                    // 设置边框线
+                    addRowRange.setBorder(new GC.Spread.Sheets.LineBorder('#000', GC.Spread.Sheets.LineStyle.thin), { all: true });
+                    addRowRange.setBorder(new GC.Spread.Sheets.LineBorder('#000', GC.Spread.Sheets.LineStyle.medium), {
+                        left: true,
+                        right: true,
+                        top: false,
+                        bottom: false,
+                    });
+                    // 设置单元格水平和垂直居中
+                    addRowRange.hAlign(GC.Spread.Sheets.HorizontalAlign.center);
+                    addRowRange.vAlign(GC.Spread.Sheets.HorizontalAlign.center);
+                    sheet.setValue(lastRowIndex + 1, 1, blankRowCellValue);
+                    sheet.setTag(lastRowIndex + 1, 1, 'BlankCell');
+                }
+                else {
+                    // 设置添加这一行的行高
+                    sheet.setRowHeight(lastRowIndex + 1, sheetTotalHeight - allRowHeight);
+                    // 显示空白行单元格
+                    sheet.setRowVisible(lastRowIndex + 1, true);
+                }
+            }
+            // 隐藏空白行单元格
+            else {
+                const blankRowCell = sheet.getTag(lastRowIndex + 1, 1);
+                // 如果空白行单元格标签存在，则隐藏
+                if (blankRowCell && blankRowCell == 'BlankCell') {
+                    sheet.setRowVisible(lastRowIndex + 1, false);
+                }
+            }
+        };
+        createBlackRowCell();
+        // // 处理单元格边框线的问题
+        // const allRowIndex = orderByJson(unionJson(hasValueRows, noValueRows));
+        // const rowRange = sheet.getRange(allRowIndex[0], 1, allRowIndex.length, 77);
+        // rowRange.setBorder(new GC.Spread.Sheets.LineBorder('#000', GC.Spread.Sheets.LineStyle.thin), { all: true });
+        // rowRange.setBorder(new GC.Spread.Sheets.LineBorder('#000', GC.Spread.Sheets.LineStyle.medium), {
+        //   left: true,
+        //   right: true,
+        //   top: false,
+        //   bottom: false,
+        // });
+        // 恢复绘制
+        sheet.resumePaint();
+        return { hasValueIndex: hasValueRows, noValueIndex: noValueRows };
+    },
+    /**
+     * 动态加载行（动态显示数据行和序号值）
+     * @param GC GC对象
+     * @param spread 工作簿实例
+     * @param dynamicLoadRangeJson 动态加载的“试验结果”JSON数组范围，格式如：[{row: 1, col: 1, rowCount: 1, colCount: 1}]
+     * @param headerRangeHeight 表头区域总高度
+     * @param footerRangeHeight 表尾区域总高度
+     * @param remainingHeight 剩余高度（针对纵表情况，工作表总高度-表头和表尾总高度>=remainingHeight，空白行不显示；<remainingHeight，空白行显示）
+     * @param pageDir 页面方向（1：纵向、2：横向）
+     * @param blankRowCellValue 空白行单元格值，默认为：空白
+     * @returns 返回所有需要显示和隐藏的行索引结果对象，格式如：{hasValueIndex: [1, 2, 3], noValueIndex: [4, 5, 6]}，hasValueIndex代表所有显示的行索引，noValueIndex代表所有隐藏的行索引
+     */
+    dynamicLoadRows_Backup: (GC, spread, dynamicLoadRangeJson, headerRangeHeight, footerRangeHeight, remainingHeight = 500, pageDir = 1, blankRowCellValue = '空白') => {
         const sheet = spread.getActiveSheet();
         // 暂停绘制
         sheet.suspendPaint();
@@ -15889,37 +16114,77 @@ const FormulaUtils = {
                 return retData.allCellVals.length;
             },
         },
+        // {
+        //   funName: 'YjMid',
+        //   funDesc: '获取所有选择的单元格中的中间值',
+        //   funDefaultVal: null,
+        //   funParams: [
+        //     {
+        //       name: '数值1',
+        //       repeatable: false,
+        //       optional: false,
+        //     },
+        //     {
+        //       name: '数值2',
+        //       repeatable: false,
+        //       optional: false,
+        //     },
+        //     {
+        //       name: '数值3',
+        //       repeatable: false,
+        //       optional: false,
+        //     },
+        //   ],
+        //   funCallback: (spread, sheet, retData) => {
+        //     //得到所有参数中为数字的集合，即：数字参数才参与计算
+        //     retData.allCellVals = retData.allCellVals.filter((item) => FormulaUtils.commFun.isNumber(item));
+        //     //如果传递的参数小于3个，则返回0
+        //     if (retData.allCellVals.length < 3) {
+        //       return 0;
+        //     }
+        //     let retArrVals: Array<number> = FormulaUtils.commFun.convertToInt(retData.allCellVals);
+        //     const maxVal = Math.max(...retArrVals),
+        //       minVal = Math.min(...retArrVals);
+        //     return retArrVals[0] * 1 + retArrVals[1] * 1 + retArrVals[2] * 1 - maxVal * 1 - minVal * 1;
+        //   },
+        // },
         {
-            funName: 'YjMid',
+            funName: 'YJMID',
             funDesc: '获取所有选择的单元格中的中间值',
             funDefaultVal: null,
             funParams: [
                 {
-                    name: '数值1',
-                    repeatable: false,
-                    optional: false,
-                },
-                {
-                    name: '数值2',
-                    repeatable: false,
-                    optional: false,
-                },
-                {
-                    name: '数值3',
+                    name: '单元格范围',
                     repeatable: false,
                     optional: false,
                 },
             ],
             funCallback: (spread, sheet, retData) => {
-                //得到所有参数中为数字的集合，即：数字参数才参与计算
-                retData.allCellVals = retData.allCellVals.filter((item) => FormulaUtils.commFun.isNumber(item));
-                //如果传递的参数小于3个，则返回0
-                if (retData.allCellVals.length < 3) {
-                    return 0;
+                // 步骤1：过滤有效数字（包括数字字符串，如'8'），排除null、undefined、空字符串、'/'、0
+                const validNumbers = retData.allCellVals
+                    .filter((item) => {
+                    // 将项转换为数字
+                    const num = Number(item);
+                    // 检查是否为有效数字：非NaN、非0、非无穷大，且原始项不是空字符串或'/'
+                    return !isNaN(num) && num !== 0 && isFinite(num) && item !== '' && item !== '/';
+                })
+                    .map((item) => Number(item)); // 确保所有项都是数字类型
+                // 如果没有有效数字，返回'/'
+                if (validNumbers.length === 0) {
+                    return '/';
+                }
+                // 步骤2：对数字进行升序排序
+                validNumbers.sort((a, b) => a - b);
+                // 步骤3：计算中位数
+                const midIndex = Math.floor(validNumbers.length / 2);
+                // 数组长度为奇数：返回中间值
+                if (validNumbers.length % 2 === 1) {
+                    return validNumbers[midIndex];
+                }
+                // 数组长度为偶数：返回中间两个值的平均值
+                else {
+                    return (validNumbers[midIndex - 1] + validNumbers[midIndex]) / 2;
                 }
-                let retArrVals = FormulaUtils.commFun.convertToInt(retData.allCellVals);
-                const maxVal = Math.max(...retArrVals), minVal = Math.min(...retArrVals);
-                return retArrVals[0] * 1 + retArrVals[1] * 1 + retArrVals[2] * 1 - maxVal * 1 - minVal * 1;
             },
         },
         {