@onco-foundry/mask-port 0.1.3 → 0.1.5

package/dist/textin_masker.d.ts

@@ -23,6 +23,8 @@ export type TextInMaskerOptions = {
     readonly baseURL?: string;
     readonly timeoutMs?: number;
     readonly maxInputBytes?: number;
+    /** 自动处理链路使用：已发现的敏感词无法完整定位时拒绝交付。 */
+    readonly requireAllMatches?: boolean;
     /** 测试注入缝：替换掉真实的 HTTP 层，不碰网络。 */
     readonly fetch?: typeof fetch;
     /**
@@ -35,6 +37,6 @@ export type TextInMaskerOptions = {
 export declare const findSensitiveWordsByRules: (text: string) => readonly SensitiveWord[];
 /**
  * 创建 TextIn 识别脱敏器。凭证在 create 时一次绑定，之后 mask 只传业务参数。
- * 同一敏感词在一行出现多次时逐处遮盖、逐处登记 mapping（占位符按类别各自编号）。
+ * 同一敏感词出现多次时逐处遮盖、逐处登记 mapping；跨行命中拆成多个框，仍登记为一个实体。
  */
 export declare const createTextInMasker: (options: TextInMaskerOptions) => Masker;

package/dist/textin_masker.js

@@ -82,9 +82,39 @@ const locateWordQuad = (line, beginIndex, wordLength) => {
     return line.position === undefined ? undefined : toQuad(line.position);
 };
 const scaleQuadToImage = (quad, scaleX, scaleY) => quad.map(([x, y]) => [x * scaleX, y * scaleY]);
+/**
+ * Find exact occurrences against the same newline-joined text seen by the finder,
+ * then split each occurrence into line-local spans for geometry lookup.
+ */
+const locateWordSpans = (lines, recognizedText, word) => {
+    const lineRanges = [];
+    let offset = 0;
+    for (const line of lines) {
+        lineRanges.push({ line, start: offset, end: offset + line.text.length });
+        offset += line.text.length + 1;
+    }
+    const occurrences = [];
+    let fromIndex = 0;
+    while (word.length > 0) {
+        const hit = recognizedText.indexOf(word, fromIndex);
+        if (hit < 0)
+            break;
+        fromIndex = hit + word.length;
+        const end = hit + word.length;
+        const spans = lineRanges.flatMap(range => {
+            const spanStart = Math.max(hit, range.start);
+            const spanEnd = Math.min(end, range.end);
+            return spanStart < spanEnd
+                ? [{ line: range.line, beginIndex: spanStart - range.start, length: spanEnd - spanStart }]
+                : [];
+        });
+        occurrences.push(spans);
+    }
+    return occurrences;
+};
 /**
  * 创建 TextIn 识别脱敏器。凭证在 create 时一次绑定，之后 mask 只传业务参数。
- * 同一敏感词在一行出现多次时逐处遮盖、逐处登记 mapping（占位符按类别各自编号）。
+ * 同一敏感词出现多次时逐处遮盖、逐处登记 mapping；跨行命中拆成多个框，仍登记为一个实体。
  */
 export const createTextInMasker = (options) => {
     const credentials = z.object({
@@ -156,28 +186,61 @@ export const createTextInMasker = (options) => {
             if (payload.data.code !== 200 || payload.data.result === undefined) {
                 throw new AppError(`TextIn 脱敏接口报错：${payload.data.code} ${payload.data.message}`, 502);
             }
+            if (options.requireAllMatches && payload.data.result.pages.length !== 1) {
+                throw new AppError('TextIn 脱敏需要单页图片识别结果', 502);
+            }
             const page = payload.data.result.pages[0];
             const lines = page.lines;
             const recognizedText = lines.map((line) => line.text).join('\n');
             const scaleX = page.width !== undefined && page.width > 0 ? imageWidth / page.width : 1;
             const scaleY = page.height !== undefined && page.height > 0 ? imageHeight / page.height : 1;
-            const requested = (await finder(recognizedText))
+            if (options.requireAllMatches && !recognizedText.trim()) {
+                throw new AppError('TextIn 脱敏未识别出文字，无法确认处理结果', 502);
+            }
+            const detected = await finder(recognizedText);
+            if (options.requireAllMatches && detected.some(word => !word.text || !(word.target in TARGET_LABELS) || !recognizedText.includes(word.text))) {
+                throw new AppError('TextIn 脱敏判定结果无法定位', 502);
+            }
+            const requested = detected
                 .filter((word) => word.text !== '' && request.targets.includes(word.target));
             const finalQuads = [];
             const mappings = [];
             const counters = new Map();
             for (const word of requested) {
-                for (const line of lines) {
-                    let fromIndex = 0;
-                    while (true) {
-                        const hit = line.text.indexOf(word.text, fromIndex);
-                        if (hit < 0)
+                let located = 0;
+                for (const spans of locateWordSpans(lines, recognizedText, word.text)) {
+                    const occurrenceQuads = [];
+                    let complete = spans.length > 0;
+                    for (const span of spans) {
+                        const locatedLine = options.requireAllMatches && span.line.char_positions?.length !== span.line.text.length
+                            ? { ...span.line, char_positions: undefined } : span.line;
+                        const quad = locateWordQuad(locatedLine, span.beginIndex, span.length);
+                        if (quad === undefined) {
+                            if (options.requireAllMatches)
+                                throw new AppError('TextIn 脱敏敏感词缺少坐标', 502);
+                            complete = false;
                             break;
-                        fromIndex = hit + word.text.length;
-                        const quad = locateWordQuad(line, hit, word.text.length);
-                        if (quad === undefined)
-                            continue;
-                        finalQuads.push(clampQuad(scaleQuad(scaleQuadToImage(quad, scaleX, scaleY), SAFETY_SCALE), imageWidth, imageHeight));
+                        }
+                        if (options.requireAllMatches) {
+                            const scaled = scaleQuadToImage(quad, scaleX, scaleY);
+                            const xs = scaled.map(point => point[0]);
+                            const ys = scaled.map(point => point[1]);
+                            const area = Math.abs(scaled.reduce((sum, [x, y], index) => {
+                                const next = scaled[(index + 1) % scaled.length];
+                                return sum + x * next[1] - next[0] * y;
+                            }, 0));
+                            if (area < 1 || scaled.flat().some(n => !Number.isFinite(n)) ||
+                                Math.min(...xs) < 0 || Math.min(...ys) < 0 ||
+                                Math.max(...xs) > imageWidth || Math.max(...ys) > imageHeight ||
+                                Math.max(...xs) <= Math.min(...xs) || Math.max(...ys) <= Math.min(...ys)) {
+                                throw new AppError('TextIn 脱敏坐标无效', 502);
+                            }
+                        }
+                        occurrenceQuads.push(clampQuad(scaleQuad(scaleQuadToImage(quad, scaleX, scaleY), SAFETY_SCALE), imageWidth, imageHeight));
+                    }
+                    if (complete && occurrenceQuads.length > 0) {
+                        located++;
+                        finalQuads.push(...occurrenceQuads);
                         const count = (counters.get(word.target) ?? 0) + 1;
                         counters.set(word.target, count);
                         mappings.push({
@@ -187,6 +250,9 @@ export const createTextInMasker = (options) => {
                         });
                     }
                 }
+                if (options.requireAllMatches && located === 0) {
+                    throw new AppError('TextIn 脱敏敏感词无法定位', 502);
+                }
             }
             const overlay = polygonSvg(imageWidth, imageHeight, finalQuads);
             const uprightMasked = await sharp(upright.data)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onco-foundry/mask-port",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "type": "module",
   "files": [
     "dist",
@@ -16,10 +16,10 @@
     "agent-lattice": "0.25.0",
     "sharp": "^0.35.3",
     "zod": "^4.4.3",
-    "@onco-foundry/resource-versioning": "0.2.0",
-    "@onco-foundry/trace-port": "0.3.2",
     "@onco-foundry/errors": "0.1.1",
-    "@onco-foundry/capability-registry": "0.1.1"
+    "@onco-foundry/capability-registry": "0.1.1",
+    "@onco-foundry/trace-port": "0.3.2",
+    "@onco-foundry/resource-versioning": "0.3.0"
   },
   "publishConfig": {
     "access": "public"