rapid-spreadjs 1.0.171 → 1.0.173

package/dist/index.cjs.js

@@ -1523,16 +1523,26 @@ const BusinessUtils = {
                 });
             }
         });
-        let serNum = 0;
-        hasValueRowsSer.forEach((rowIndex, index) => {
-            const curVal = sheet.getValue(rowIndex, 1);
-            // 检查第一个单元格的值是否包含非数字字符，有非数字字符的时候代表不填充序号
-            if (!/^(?!\d+$)[\u4e00-\u9fa5a-zA-Z0-9!@#$%^&*()_+[\]{};':",.\/?\\|-]+$/.test(curVal)) {
-                serNum++;
+        // 禁用的时候，将所有的序号重新设置
+        if (!isEnable) {
+            rowCells.forEach((rowObj, index) => {
                 // 设置序号列单元格的值（1、2、3...的格式）
-                sheet.setValue(rowIndex, 1, serNum);
-            }
-        });
+                sheet.setValue(rowObj.rowSpan, 1, index + 1);
+            });
+        }
+        // 启用的时候
+        else {
+            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);
@@ -1654,207 +1664,6 @@ const BusinessUtils = {
         }
         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();
-        // 获取所有单元格对象
-        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)) {
-                rowCells.push({
-                    rowSpan: seqColSpanObj.row,
-                    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);
-                        }
-                    });
-                });
-            }
-            else {
-                rowObj.rows.forEach((x) => {
-                    x.rows.forEach((rowIndex) => {
-                        if (!noValueRows.some((hItem) => hItem == rowIndex)) {
-                            noValueRows.push(rowIndex);
-                        }
-                    });
-                });
-            }
-        });
-        hasValueRowsSer.forEach((rowIndex, index) => {
-            // 设置序号列单元格的值（1、2、3...的格式）
-            sheet.setValue(rowIndex, 1, index + 1);
-        });
-        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 = 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 };
-    },
 };
 
 /**
@@ -23993,6 +23802,78 @@ const FormulaUtils = {
                 return qdhsz;
             },
         },
+        {
+            funName: 'YJZBPD',
+            funDesc: '报告上根据技术要求进行坐标判定',
+            funDefaultVal: null,
+            funParams: [
+                {
+                    name: '四边形坐标，格式如 (0,0):(3,7):(15,8):(9.5,3.3)',
+                    repeatable: false,
+                    optional: false,
+                },
+                {
+                    name: '目标点x坐标',
+                    repeatable: false,
+                    optional: false,
+                },
+                {
+                    name: '目标点y坐标',
+                    repeatable: false,
+                    optional: false,
+                },
+            ],
+            funCallback: (spread, sheet, retData) => {
+                // 如果传递的参数小于3个，则返回/
+                if (retData.allCellVals.length < 3) {
+                    return '/';
+                }
+                let points = retData.allCellVals[0], xPoint = retData.allCellVals[1], yPoint = retData.allCellVals[2];
+                // 1. 格式校验
+                if (typeof points !== 'string' || !points)
+                    return '/';
+                const regex = /^\s*\(\s*(-?\d+(?:\.\d+)?)\s*,\s*(-?\d+(?:\.\d+)?)\s*\)\s*:\s*\(\s*(-?\d+(?:\.\d+)?)\s*,\s*(-?\d+(?:\.\d+)?)\s*\)\s*:\s*\(\s*(-?\d+(?:\.\d+)?)\s*,\s*(-?\d+(?:\.\d+)?)\s*\)\s*:\s*\(\s*(-?\d+(?:\.\d+)?)\s*,\s*(-?\d+(?:\.\d+)?)\s*\)\s*$/;
+                const match = points.match(regex);
+                if (!match)
+                    return '/';
+                // 2. 解析坐标
+                const coords = [];
+                for (let i = 1; i < match.length; i += 2) {
+                    coords.push({ x: parseFloat(match[i]), y: parseFloat(match[i + 1]) });
+                }
+                const tx = Number(xPoint), ty = Number(yPoint);
+                if (isNaN(tx) || isNaN(ty))
+                    return '/';
+                // 3. 【新增】边界判定：点到线段距离 ≤ 容差 → 直接合格
+                const EPSILON = 1e-9;
+                function pointToSegmentDistSq(px, py, ax, ay, bx, by) {
+                    const dx = bx - ax, dy = by - ay;
+                    const lenSq = dx * dx + dy * dy;
+                    if (lenSq === 0)
+                        return (px - ax) ** 2 + (py - ay) ** 2; // 退化为点
+                    let t = ((px - ax) * dx + (py - ay) * dy) / lenSq;
+                    t = Math.max(0, Math.min(1, t)); // 钳制到 [0,1]
+                    const projX = ax + t * dx, projY = ay + t * dy;
+                    return (px - projX) ** 2 + (py - projY) ** 2;
+                }
+                const n = coords.length;
+                for (let i = 0, j = n - 1; i < n; j = i++) {
+                    const distSq = pointToSegmentDistSq(tx, ty, coords[j].x, coords[j].y, coords[i].x, coords[i].y);
+                    if (distSq <= EPSILON * EPSILON)
+                        return '合格';
+                }
+                // 4. 射线法判定内部
+                let inside = false;
+                for (let i = 0, j = n - 1; i < n; j = i++) {
+                    const xi = coords[i].x, yi = coords[i].y;
+                    const xj = coords[j].x, yj = coords[j].y;
+                    const intersect = yi > ty !== yj > ty && tx < ((xj - xi) * (ty - yi)) / (yj - yi) + xi;
+                    if (intersect)
+                        inside = !inside;
+                }
+                return inside ? '合格' : '不合格';
+            },
+        },
         {
             funName: 'YJTEST',
             funDesc: '云检测试函数',