@liuhange/dsh-underground-pipeline-inspector 1.0.0

package/config/pipeline-attribute-config.json

@@ -0,0 +1,80 @@
+{
+  "version": "1.0.0",
+  "lastUpdated": "2026-10-01",
+  "diameterRange": {
+    "description": "管径值域，单位毫米",
+    "minMm": 0,
+    "maxMm": 3000,
+    "policyBasis": "依据：《信息技术 地下管线数据交换技术要求》（GB/T 29806-2013）第6.3.4条"
+  },
+  "materialEnum": {
+    "description": "管材材质枚举",
+    "allowedValues": [
+      "钢管",
+      "铸铁管",
+      "球墨铸铁管",
+      "钢筋混凝土管",
+      "混凝土管",
+      "陶土管",
+      "PVC管",
+      "PE管",
+      "HDPE管",
+      "玻璃钢管",
+      "塑料管",
+      "其他"
+    ],
+    "policyBasis": "依据：《信息技术 地下管线数据交换技术要求》（GB/T 29806-2013）第6.3.5条"
+  },
+  "buryMethodEnum": {
+    "description": "埋设方式枚举",
+    "allowedValues": [
+      "直埋",
+      "管沟",
+      "顶管",
+      "拖拉管",
+      "盾构",
+      "其他"
+    ],
+    "policyBasis": "依据：《信息技术 地下管线数据交换技术要求》（GB/T 29806-2013）第6.3.6条"
+  },
+  "flowDirectionEnum": {
+    "description": "排水流向枚举",
+    "allowedValues": [
+      "顺流",
+      "逆流",
+      "未知"
+    ],
+    "policyBasis": "依据：《城镇排水管渠运行维护及安全技术规程》（CJJ 68-2016）第3.2.4条"
+  },
+  "attributeSpec": {
+    "description": "属性项规范，字段名称与最大长度约束",
+    "fieldConstraints": [
+      {
+        "fieldName": "pointId",
+        "maxLength": 32,
+        "policyBasis": "依据：《信息技术 地下管线数据交换技术要求》（GB/T 29806-2013）第6.2.1条"
+      },
+      {
+        "fieldName": "segmentId",
+        "maxLength": 32,
+        "policyBasis": "依据：《信息技术 地下管线数据交换技术要求》（GB/T 29806-2013）第6.2.2条"
+      },
+      {
+        "fieldName": "pointType",
+        "maxLength": 16,
+        "policyBasis": "依据：《信息技术 地下管线数据交换技术要求》（GB/T 29806-2013）第6.2.3条"
+      },
+      {
+        "fieldName": "material",
+        "maxLength": 16,
+        "policyBasis": "依据：《信息技术 地下管线数据交换技术要求》（GB/T 29806-2013）第6.3.5条"
+      },
+      {
+        "fieldName": "buryMethod",
+        "maxLength": 16,
+        "policyBasis": "依据：《信息技术 地下管线数据交换技术要求》（GB/T 29806-2013）第6.3.6条"
+      }
+    ],
+    "policyBasis": "依据：《信息技术 地下管线数据交换技术要求》（GB/T 29806-2013）第6.2条"
+  }
+}

package/config/pipeline-inspection-config.json

@@ -0,0 +1,67 @@
+{
+  "version": "1.0.0",
+  "lastUpdated": "2026-10-01",
+  "workspace": {
+    "description": "巡检工作区范围定义，含图层名称与边界",
+    "requiredLayers": [
+      "pipeline_point",
+      "pipeline_segment",
+      "pipeline_structure"
+    ],
+    "policyBasis": "依据：《地下管线数据获取规程》（GB/T 35644-2017）第5.1条"
+  },
+  "edgeMatching": {
+    "description": "接边点坐标容差，单位米",
+    "toleranceMeter": 0.005,
+    "policyBasis": "依据：《城市地下管线探测技术规程》（CJJ 61-2017）第4.6.2条"
+  },
+  "legalCoordinateSystems": {
+    "description": "合法坐标系枚举",
+    "allowedSridList": [
+      "CGCS2000_3_degree_GK_Zone_38",
+      "CGCS2000_3_degree_GK_Zone_39",
+      "CGCS2000_3_degree_GK_Zone_40",
+      "CGCS2000"
+    ],
+    "policyBasis": "依据：《地下管线数据获取规程》（GB/T 35644-2017）第5.2.2条"
+  },
+  "verticalDatum": {
+    "description": "合法高程基准枚举",
+    "allowedDatumList": [
+      "1985国家高程基准",
+      "1956黄海高程系",
+      "地方独立高程基准"
+    ],
+    "policyBasis": "依据：《地下管线数据获取规程》（GB/T 35644-2017）第5.2.3条"
+  },
+  "connectivity": {
+    "description": "连通性要求，管线点最小连通管段数与最大连通管段数",
+    "minConnectedSegments": 1,
+    "maxConnectedSegments": 4,
+    "policyBasis": "依据：《地下管线数据获取规程》（GB/T 35644-2017）第6.3条"
+  },
+  "grossErrorRate": {
+    "description": "管线点粗差率阈值，超过则不合格",
+    "thresholdRate": 0.05,
+    "policyBasis": "依据：《广东省地下管线数据检查导则》第7.3.11条"
+  },
+  "fieldIntegrity": {
+    "description": "管线点与管段必填字段清单",
+    "pipelinePointRequiredFields": [
+      "pointId",
+      "pointType",
+      "x",
+      "y",
+      "elevation"
+    ],
+    "pipelineSegmentRequiredFields": [
+      "segmentId",
+      "startPointId",
+      "endPointId",
+      "diameter",
+      "material",
+      "buryMethod"
+    ],
+    "policyBasis": "依据：《信息技术 地下管线数据交换技术要求》（GB/T 29806-2013）第6.2条"
+  }
+}

package/config/quality-element-config.json

@@ -0,0 +1,55 @@
+{
+  "version": "1.0.0",
+  "lastUpdated": "2026-10-01",
+  "qualityElements": {
+    "description": "六类质量元素及权重，等权配置",
+    "elements": [
+      {
+        "elementName": "空间参考系",
+        "weight": 0.1667,
+        "policyBasis": "依据：《测绘成果质量检查与验收》（GB/T 24356-2023）第6.1条"
+      },
+      {
+        "elementName": "位置精度",
+        "weight": 0.1667,
+        "policyBasis": "依据：《测绘成果质量检查与验收》（GB/T 24356-2023）第6.2条"
+      },
+      {
+        "elementName": "逻辑一致性",
+        "weight": 0.1667,
+        "policyBasis": "依据：《测绘成果质量检查与验收》（GB/T 24356-2023）第6.3条"
+      },
+      {
+        "elementName": "时间精度",
+        "weight": 0.1667,
+        "policyBasis": "依据：《测绘成果质量检查与验收》（GB/T 24356-2023）第6.4条"
+      },
+      {
+        "elementName": "栅格质量",
+        "weight": 0.1666,
+        "policyBasis": "依据：《测绘成果质量检查与验收》（GB/T 24356-2023）第6.5条"
+      },
+      {
+        "elementName": "附件质量",
+        "weight": 0.1666,
+        "policyBasis": "依据：《测绘成果质量检查与验收》（GB/T 24356-2023）第6.6条"
+      }
+    ],
+    "policyBasis": "依据：《测绘成果质量检查与验收》（GB/T 24356-2023）第6章"
+  },
+  "errorClassThresholds": {
+    "description": "A/B/C/D错误分类扣分阈值，A类最严重",
+    "classAScoreDeduction": 1.0,
+    "classBScoreDeduction": 0.6,
+    "classCScoreDeduction": 0.3,
+    "classDScoreDeduction": 0.1,
+    "policyBasis": "依据：《测绘成果质量检查与验收》（GB/T 24356-2023）第7.2条"
+  },
+  "qualityGradeThresholds": {
+    "description": "质量等级划分阈值，合格分下限",
+    "excellentMinScore": 90,
+    "goodMinScore": 80,
+    "qualifiedMinScore": 70,
+    "policyBasis": "依据：《测绘成果质量检查与验收》（GB/T 24356-2023）第8.1条"
+  }
+}

package/cordis.patch.yml

@@ -0,0 +1,9 @@
+# Cordis Framework Patch Declaration for @liuhange/dsh-underground-pipeline-inspector
+# This file declares the plugin's runtime patch for the Cordis framework.
+# Used by DSH plugin manager to apply framework-level patches during installation.
+plugin: @liuhange/dsh-underground-pipeline-inspector
+version: 1.0.0
+patch:
+  - target: tools
+    action: register
+    description: Register plugin tools into Cordis runtime

package/lib/attribute-precision-checker.js

@@ -0,0 +1,108 @@
+export class AttributePrecisionChecker {
+    check(dataset, config) {
+        const checkResults = [];
+        const invalidDiameter = [];
+        const invalidMaterial = [];
+        const invalidBuryMethod = [];
+        const invalidFlowDirection = [];
+        const fieldLengthViolations = [];
+        const materialSet = new Set(config.materialEnum.allowedValues);
+        const buryMethodSet = new Set(config.buryMethodEnum.allowedValues);
+        const flowDirectionSet = new Set(config.flowDirectionEnum.allowedValues);
+        const constraintMap = new Map();
+        for (const constraint of config.attributeSpec.fieldConstraints) {
+            constraintMap.set(constraint.fieldName, constraint.maxLength);
+        }
+        for (const segment of dataset.segments) {
+            if (segment.diameter < config.diameterRange.minMm ||
+                segment.diameter > config.diameterRange.maxMm) {
+                invalidDiameter.push({
+                    segmentId: segment.segmentId,
+                    description: `管段 ${segment.segmentId} 管径 ${segment.diameter} 不在值域 [${config.diameterRange.minMm}, ${config.diameterRange.maxMm}] 内`,
+                });
+                checkResults.push({
+                    checkName: '管径值域检查',
+                    errorClass: 'C',
+                    objectId: segment.segmentId,
+                    description: `管段 ${segment.segmentId} 管径 ${segment.diameter} 不在值域 [${config.diameterRange.minMm}, ${config.diameterRange.maxMm}] 内`,
+                    policyBasis: config.diameterRange.policyBasis,
+                });
+            }
+            if (!materialSet.has(segment.material)) {
+                invalidMaterial.push({
+                    segmentId: segment.segmentId,
+                    description: `管段 ${segment.segmentId} 材质 ${segment.material} 不在合法枚举中`,
+                });
+                checkResults.push({
+                    checkName: '材质枚举检查',
+                    errorClass: 'C',
+                    objectId: segment.segmentId,
+                    description: `管段 ${segment.segmentId} 材质 ${segment.material} 不在合法枚举中`,
+                    policyBasis: config.materialEnum.policyBasis,
+                });
+            }
+            if (!buryMethodSet.has(segment.buryMethod)) {
+                invalidBuryMethod.push({
+                    segmentId: segment.segmentId,
+                    description: `管段 ${segment.segmentId} 埋设方式 ${segment.buryMethod} 不在合法枚举中`,
+                });
+                checkResults.push({
+                    checkName: '埋设方式枚举检查',
+                    errorClass: 'C',
+                    objectId: segment.segmentId,
+                    description: `管段 ${segment.segmentId} 埋设方式 ${segment.buryMethod} 不在合法枚举中`,
+                    policyBasis: config.buryMethodEnum.policyBasis,
+                });
+            }
+            if (segment.flowDirection !== undefined && !flowDirectionSet.has(segment.flowDirection)) {
+                invalidFlowDirection.push({
+                    segmentId: segment.segmentId,
+                    description: `管段 ${segment.segmentId} 流向 ${segment.flowDirection} 不在合法枚举中`,
+                });
+                checkResults.push({
+                    checkName: '流向枚举检查',
+                    errorClass: 'C',
+                    objectId: segment.segmentId,
+                    description: `管段 ${segment.segmentId} 流向 ${segment.flowDirection} 不在合法枚举中`,
+                    policyBasis: config.flowDirectionEnum.policyBasis,
+                });
+            }
+            this.checkFieldLength(segment.segmentId, 'segmentId', segment.segmentId, constraintMap, fieldLengthViolations, checkResults, config.attributeSpec.policyBasis);
+            this.checkFieldLength(segment.segmentId, 'material', segment.material, constraintMap, fieldLengthViolations, checkResults, config.attributeSpec.policyBasis);
+            this.checkFieldLength(segment.segmentId, 'buryMethod', segment.buryMethod, constraintMap, fieldLengthViolations, checkResults, config.attributeSpec.policyBasis);
+        }
+        for (const point of dataset.points) {
+            this.checkFieldLength(point.pointId, 'pointId', point.pointId, constraintMap, fieldLengthViolations, checkResults, config.attributeSpec.policyBasis);
+            this.checkFieldLength(point.pointId, 'pointType', point.pointType, constraintMap, fieldLengthViolations, checkResults, config.attributeSpec.policyBasis);
+        }
+        const attributeResult = {
+            invalidDiameter,
+            invalidMaterial,
+            invalidBuryMethod,
+            invalidFlowDirection,
+            fieldLengthViolations,
+            policyBasis: config.attributeSpec.policyBasis,
+        };
+        return { attributeResult, checkResults };
+    }
+    checkFieldLength(objectId, fieldName, value, constraintMap, violations, checkResults, policyBasis) {
+        const maxLength = constraintMap.get(fieldName);
+        if (maxLength === undefined)
+            return;
+        if (value.length > maxLength) {
+            violations.push({
+                objectId,
+                fieldName,
+                description: `对象 ${objectId} 字段 ${fieldName} 长度 ${value.length} 超过最大长度 ${maxLength}`,
+            });
+            checkResults.push({
+                checkName: '属性项规范检查',
+                errorClass: 'C',
+                objectId,
+                description: `对象 ${objectId} 字段 ${fieldName} 长度 ${value.length} 超过最大长度 ${maxLength}`,
+                policyBasis,
+            });
+        }
+    }
+}
+//# sourceMappingURL=attribute-precision-checker.js.map

package/lib/coordinate-checker.js

@@ -0,0 +1,44 @@
+export class CoordinateChecker {
+    check(dataset, config) {
+        const checkResults = [];
+        const missingCoordinatePoints = [];
+        const pointMap = new Map();
+        for (const point of dataset.points) {
+            pointMap.set(point.pointId, true);
+        }
+        for (const segment of dataset.segments) {
+            if (!pointMap.has(segment.startPointId)) {
+                missingCoordinatePoints.push({
+                    pointId: segment.startPointId,
+                    description: `管段 ${segment.segmentId} 起点引用 ${segment.startPointId} 不存在，无法定位坐标`,
+                });
+                checkResults.push({
+                    checkName: '缺坐标检查',
+                    errorClass: 'B',
+                    objectId: segment.segmentId,
+                    description: `管段 ${segment.segmentId} 起点引用 ${segment.startPointId} 不存在，无法定位坐标`,
+                    policyBasis: config.fieldIntegrity.policyBasis,
+                });
+            }
+            if (!pointMap.has(segment.endPointId)) {
+                missingCoordinatePoints.push({
+                    pointId: segment.endPointId,
+                    description: `管段 ${segment.segmentId} 终点引用 ${segment.endPointId} 不存在，无法定位坐标`,
+                });
+                checkResults.push({
+                    checkName: '缺坐标检查',
+                    errorClass: 'B',
+                    objectId: segment.segmentId,
+                    description: `管段 ${segment.segmentId} 终点引用 ${segment.endPointId} 不存在，无法定位坐标`,
+                    policyBasis: config.fieldIntegrity.policyBasis,
+                });
+            }
+        }
+        const coordinateResult = {
+            missingCoordinatePoints,
+            policyBasis: config.fieldIntegrity.policyBasis,
+        };
+        return { coordinateResult, checkResults };
+    }
+}
+//# sourceMappingURL=coordinate-checker.js.map

package/lib/coverage-checker.js

@@ -0,0 +1,83 @@
+export class CoverageChecker {
+    check(dataset, config) {
+        const checkResults = [];
+        const missingLayers = [];
+        const fieldErrors = [];
+        const presentLayers = new Set(dataset.workspaceLayers ?? []);
+        for (const requiredLayer of config.workspace.requiredLayers) {
+            if (!presentLayers.has(requiredLayer)) {
+                missingLayers.push(requiredLayer);
+                checkResults.push({
+                    checkName: '工作区图层覆盖检查',
+                    errorClass: 'B',
+                    objectId: requiredLayer,
+                    description: `工作区缺少必需图层: ${requiredLayer}`,
+                    policyBasis: config.workspace.policyBasis,
+                });
+            }
+        }
+        for (const point of dataset.points) {
+            const missing = this.checkPointFields(point, config.fieldIntegrity.pipelinePointRequiredFields);
+            if (missing.length > 0) {
+                fieldErrors.push({
+                    objectId: point.pointId,
+                    missingFields: missing,
+                    errorMessage: '管线点必填字段缺失',
+                });
+                checkResults.push({
+                    checkName: '管线点字段完整性检查',
+                    errorClass: 'B',
+                    objectId: point.pointId,
+                    description: `管线点 ${point.pointId} 缺少字段: ${missing.join(', ')}`,
+                    policyBasis: config.fieldIntegrity.policyBasis,
+                });
+            }
+        }
+        for (const segment of dataset.segments) {
+            const missing = this.checkSegmentFields(segment, config.fieldIntegrity.pipelineSegmentRequiredFields);
+            if (missing.length > 0) {
+                fieldErrors.push({
+                    objectId: segment.segmentId,
+                    missingFields: missing,
+                    errorMessage: '管段必填字段缺失',
+                });
+                checkResults.push({
+                    checkName: '管段字段完整性检查',
+                    errorClass: 'B',
+                    objectId: segment.segmentId,
+                    description: `管段 ${segment.segmentId} 缺少字段: ${missing.join(', ')}`,
+                    policyBasis: config.fieldIntegrity.policyBasis,
+                });
+            }
+        }
+        const coverageResult = {
+            missingLayers,
+            fieldErrors,
+            policyBasis: config.workspace.policyBasis,
+        };
+        return { coverageResult, checkResults };
+    }
+    checkPointFields(point, requiredFields) {
+        const missing = [];
+        const obj = point;
+        for (const field of requiredFields) {
+            const value = obj[field];
+            if (value === null || value === undefined || value === '') {
+                missing.push(field);
+            }
+        }
+        return missing;
+    }
+    checkSegmentFields(segment, requiredFields) {
+        const missing = [];
+        const obj = segment;
+        for (const field of requiredFields) {
+            const value = obj[field];
+            if (value === null || value === undefined || value === '') {
+                missing.push(field);
+            }
+        }
+        return missing;
+    }
+}
+//# sourceMappingURL=coverage-checker.js.map

package/lib/edge-matching-checker.js

@@ -0,0 +1,42 @@
+export class EdgeMatchingChecker {
+    check(points, config) {
+        const checkResults = [];
+        const mismatchedPairs = [];
+        const tolerance = config.edgeMatching.toleranceMeter;
+        const neighborThreshold = tolerance * 100;
+        for (let i = 0; i < points.length; i++) {
+            for (let j = i + 1; j < points.length; j++) {
+                const pointA = points[i];
+                const pointB = points[j];
+                if (pointA.pointId === pointB.pointId)
+                    continue;
+                const distance = this.calculateDistance(pointA, pointB);
+                if (distance <= neighborThreshold && distance > tolerance) {
+                    mismatchedPairs.push({
+                        pointIdA: pointA.pointId,
+                        pointIdB: pointB.pointId,
+                        distance,
+                    });
+                    checkResults.push({
+                        checkName: '接边点一致性检查',
+                        errorClass: 'B',
+                        objectId: `${pointA.pointId}-${pointB.pointId}`,
+                        description: `接边点 ${pointA.pointId} 与 ${pointB.pointId} 坐标偏差 ${distance.toFixed(6)} 米，超过容差 ${tolerance} 米`,
+                        policyBasis: config.edgeMatching.policyBasis,
+                    });
+                }
+            }
+        }
+        const edgeMatchingResult = {
+            mismatchedPairs,
+            policyBasis: config.edgeMatching.policyBasis,
+        };
+        return { edgeMatchingResult, checkResults };
+    }
+    calculateDistance(a, b) {
+        const dx = a.x - b.x;
+        const dy = a.y - b.y;
+        return Math.sqrt(dx * dx + dy * dy);
+    }
+}
+//# sourceMappingURL=edge-matching-checker.js.map

package/lib/error-classifier.js

@@ -0,0 +1,50 @@
+export class ErrorClassifier {
+    classify(checkResults, policyBasis) {
+        let classACount = 0;
+        let classBCount = 0;
+        let classCCount = 0;
+        let classDCount = 0;
+        for (const result of checkResults) {
+            switch (result.errorClass) {
+                case 'A':
+                    classACount++;
+                    break;
+                case 'B':
+                    classBCount++;
+                    break;
+                case 'C':
+                    classCCount++;
+                    break;
+                case 'D':
+                    classDCount++;
+                    break;
+            }
+        }
+        return {
+            classACount,
+            classBCount,
+            classCCount,
+            classDCount,
+            totalCount: classACount + classBCount + classCCount + classDCount,
+            policyBasis,
+        };
+    }
+    calculateProportions(stats) {
+        const total = stats.totalCount;
+        if (total === 0) {
+            return {
+                classAProportion: 0,
+                classBProportion: 0,
+                classCProportion: 0,
+                classDProportion: 0,
+            };
+        }
+        return {
+            classAProportion: Math.round((stats.classACount / total) * 10000) / 100,
+            classBProportion: Math.round((stats.classBCount / total) * 10000) / 100,
+            classCProportion: Math.round((stats.classCCount / total) * 10000) / 100,
+            classDProportion: Math.round((stats.classDCount / total) * 10000) / 100,
+        };
+    }
+}
+//# sourceMappingURL=error-classifier.js.map

package/lib/flow-direction-checker.js

@@ -0,0 +1,69 @@
+export class FlowDirectionChecker {
+    check(dataset, config) {
+        const checkResults = [];
+        const invalidFlowSegments = [];
+        const pointElevationMap = new Map();
+        for (const point of dataset.points) {
+            pointElevationMap.set(point.pointId, point.elevation);
+        }
+        const allowedFlowDirections = new Set(config.flowDirectionEnum.allowedValues);
+        for (const segment of dataset.segments) {
+            if (segment.flowDirection === undefined)
+                continue;
+            if (!allowedFlowDirections.has(segment.flowDirection)) {
+                invalidFlowSegments.push({
+                    segmentId: segment.segmentId,
+                    description: `管段 ${segment.segmentId} 流向 ${segment.flowDirection} 不在合法枚举中`,
+                });
+                checkResults.push({
+                    checkName: '排水流向检查',
+                    errorClass: 'C',
+                    objectId: segment.segmentId,
+                    description: `管段 ${segment.segmentId} 流向 ${segment.flowDirection} 不在合法枚举中`,
+                    policyBasis: config.flowDirectionEnum.policyBasis,
+                });
+                continue;
+            }
+            if (segment.flowDirection === '未知')
+                continue;
+            const startElevation = pointElevationMap.get(segment.startPointId);
+            const endElevation = pointElevationMap.get(segment.endPointId);
+            if (startElevation === undefined || endElevation === undefined)
+                continue;
+            const elevationDiff = startElevation - endElevation;
+            const epsilon = 1e-9;
+            if (segment.flowDirection === '顺流' && elevationDiff < -epsilon) {
+                invalidFlowSegments.push({
+                    segmentId: segment.segmentId,
+                    description: `管段 ${segment.segmentId} 流向为顺流但起点高程 ${startElevation} 低于终点高程 ${endElevation}`,
+                });
+                checkResults.push({
+                    checkName: '排水流向检查',
+                    errorClass: 'C',
+                    objectId: segment.segmentId,
+                    description: `管段 ${segment.segmentId} 流向为顺流但起点高程 ${startElevation} 低于终点高程 ${endElevation}`,
+                    policyBasis: config.flowDirectionEnum.policyBasis,
+                });
+            }
+            else if (segment.flowDirection === '逆流' && elevationDiff > epsilon) {
+                invalidFlowSegments.push({
+                    segmentId: segment.segmentId,
+                    description: `管段 ${segment.segmentId} 流向为逆流但起点高程 ${startElevation} 高于终点高程 ${endElevation}`,
+                });
+                checkResults.push({
+                    checkName: '排水流向检查',
+                    errorClass: 'C',
+                    objectId: segment.segmentId,
+                    description: `管段 ${segment.segmentId} 流向为逆流但起点高程 ${startElevation} 高于终点高程 ${endElevation}`,
+                    policyBasis: config.flowDirectionEnum.policyBasis,
+                });
+            }
+        }
+        const flowDirectionResult = {
+            invalidFlowSegments,
+            policyBasis: config.flowDirectionEnum.policyBasis,
+        };
+        return { flowDirectionResult, checkResults };
+    }
+}
+//# sourceMappingURL=flow-direction-checker.js.map

package/lib/gross-error-rate-calculator.js

@@ -0,0 +1,26 @@
+export class GrossErrorRateCalculator {
+    calculate(checkResults, totalPoints, config) {
+        const grossErrorPointIds = new Set();
+        for (const result of checkResults) {
+            if (result.errorClass === 'A') {
+                grossErrorPointIds.add(result.objectId);
+            }
+        }
+        const grossErrorPoints = grossErrorPointIds.size;
+        const threshold = config.grossErrorRate.thresholdRate;
+        let rate = 0;
+        if (totalPoints > 0) {
+            rate = grossErrorPoints / totalPoints;
+        }
+        const passed = rate <= threshold;
+        return {
+            totalPoints,
+            grossErrorPoints,
+            rate: Math.round(rate * 10000) / 10000,
+            threshold,
+            passed,
+            policyBasis: config.grossErrorRate.policyBasis,
+        };
+    }
+}
+//# sourceMappingURL=gross-error-rate-calculator.js.map