chaffjs 0.33.0 → 0.34.0

package/src/structure/total.ts

@@ -53,15 +53,54 @@ export const leadingText = (text: string): string =>
     .replace(/^[*_]+/u, "")
     .trimStart();
 
+/** 表の行の頭に並ぶ空の升（| | 合計 |）。最初の区切りは残す。 */
+const LEADING_BLANK_CELLS = /^([ \t]*\|)(?:[ \t]*\|)+/u;
+
+/** 表の行から頭の空の升を除いたもの。合計の語を最初の空でない升に書いた行を、最初の升に書いた行と同じに読むため。 */
+export const withoutLeadingBlankCells = (row: string): string => row.replace(LEADING_BLANK_CELLS, "$1");
+
 /**
- * 合計の語のすぐ後ろ。行や列の終わり、区切り（: |）、括弧の注記（合計（税込））、金額。
+ * 合計の語のすぐ後ろ。行や列の終わり、区切り（: |）、金額。括弧の注記は endsLabel が飛ばす。
  * 「計画」や「Total conversion: 25%」のように語が続くものは合計の行ではない。
  */
-const AFTER_LABEL = /^[*_]*[ \t\u3000]*(?:$|[:：|（(]|[-−▲△$€£¥￥\p{N}])/u;
+const AFTER_LABEL = /^[*_]*[ \t\u3000]*(?:$|[:：|]|[-−▲△$€£¥￥\p{N}])/u;
+
+/** 見出しのすぐ後ろの括弧の注記（合計（税込）、Total (incl. tax)）の開き。 */
+const NOTE_OPEN = /^[*_]*[ \t\u3000]*[（(]/u;
+const OPENERS = new Set(["(", "（"]);
+const CLOSERS = new Set([")", "）"]);
+
+type NoteScan = { readonly depth: number; readonly end: number | undefined; readonly stopped: boolean };
+
+/** 開きの括弧（start）に対応する閉じの次の位置。中の括弧は何段でもよい。升の区切り（\| でない |）までに閉じなければ undefined。 */
+const noteEnd = (text: string, start: number): number | undefined =>
+  text
+    .slice(start)
+    .split("")
+    .reduce<NoteScan>(
+      (scan, char, offset) => {
+        if (scan.end !== undefined || scan.stopped) return scan;
+        if (char === "|" && text[start + offset - 1] !== "\\") return { ...scan, stopped: true };
+        const depth = scan.depth + (OPENERS.has(char) ? 1 : 0) - (CLOSERS.has(char) ? 1 : 0);
+        return { depth, end: depth === 0 ? start + offset + 1 : undefined, stopped: false };
+      },
+      { depth: 0, end: undefined, stopped: false },
+    ).end;
+
+/**
+ * 見出しの語の後ろが見出しの終わりか。括弧の注記は飛ばして、その後ろを同じに読む。注記の後ろに語が続けば（Tax (10%) workshop、
+ * 合計（第1期）設計）、注記の付いた項目の名前。升の中で閉じない括弧は、そこからを注記とみなす。
+ */
+const endsLabel = (rest: string): boolean => {
+  const open = NOTE_OPEN.exec(rest);
+  if (open === null) return AFTER_LABEL.test(rest);
+  const end = noteEnd(rest, open[0].length - 1);
+  return end === undefined || endsLabel(rest.slice(end));
+};
 
 export const isTotalLabel = (text: string, labels: readonly string[]): boolean => {
   const lead = leadingText(text).toLowerCase();
-  return labels.some((label) => lead.startsWith(label.toLowerCase()) && AFTER_LABEL.test(lead.slice(label.length)));
+  return labels.some((label) => lead.startsWith(label.toLowerCase()) && endsLabel(lead.slice(label.length)));
 };
 
 const centsOf = (source: string, line: Line, amount: Amount): number | undefined => {

package/src/subject-codes.ts

@@ -0,0 +1,105 @@
+// The one code a product document is about (a recall's or a warranty's model): named in its title, or labelled on a line
+// of its own or in a table (型番：NH-805, | Model | MW-4120S |), and written once elsewhere with two neighbours swapped
+// (NH-850). Only when the document names no other code in those places: a catalog naming two is about two items. Pure.
+import type { LexiconEntry, Span } from "./plugin.ts";
+import { labelBefore, swapsNeighbours, withoutUrls } from "./phone-numbers.ts";
+import { charactersOf, LABEL_TO_NUMBER, REFERENCE_SHAPE, type ReferenceNumber, type ReferenceVariant } from "./reference-numbers.ts";
+import { isCodeWith } from "./unlabelled-references.ts";
+
+/** Digits enough for a model's code (FT-38); the two letters a short code must hold keep out form names (A-12, B-21). */
+export const MIN_SUBJECT_DIGITS = 2;
+const MIN_SUBJECT_LETTERS = 2;
+const LETTER = /[A-Z]/gu;
+const FIRST_PART = /^[^-‐−－]*/u;
+const TITLE_GROUP = "title";
+
+/** A short code: two letters or more before its hyphen, and two digits or more (FT-38, KR-M230; not A-12B). */
+export const isSubjectCode = (written: string): boolean =>
+  isCodeWith(MIN_SUBJECT_DIGITS)(written) && (charactersOf(FIRST_PART.exec(written)?.[0] ?? "").match(LETTER)?.length ?? 0) >= MIN_SUBJECT_LETTERS;
+
+/** What the document gives: its prose (tables masked), its title as written (the prose masks it), its labels, the groups that name an item, the codes its tables label, and every code in a table. */
+export type SubjectCodeInput = {
+  readonly prose: string;
+  readonly title: { readonly start: number; readonly text: string } | undefined;
+  readonly labels: readonly LexiconEntry[];
+  readonly listed: ReadonlySet<string>;
+  readonly tabled: readonly ReferenceNumber[];
+  readonly known: ReadonlySet<string>;
+};
+
+type CodeWriting = ReferenceNumber & { readonly anchor: boolean; readonly group: string | undefined };
+
+const lineAround = (text: string, offset: number): Span => {
+  const start = text.lastIndexOf("\n", offset - 1) + 1;
+  const end = text.indexOf("\n", offset);
+  return { start, end: end === -1 ? text.length : end };
+};
+
+/** Whether a code's line holds a label of the given labels, the separators and the code, and nothing else (型番：NH-805). */
+const isFieldLine = (text: string, offset: number, written: string, between: string, labels: readonly LexiconEntry[]): boolean => {
+  const line = lineAround(text, offset);
+  const head = text
+    .slice(line.start, offset - between.length)
+    .trim()
+    .toLowerCase();
+  const rest = text.slice(offset + written.length, line.end).trim();
+  return rest === "" && labels.some((label) => label.pattern.toLowerCase() === head);
+};
+
+const shortCodes = (text: string): RegExpExecArray[] => [...text.matchAll(REFERENCE_SHAPE)].filter((match) => isSubjectCode(match[0]));
+
+/** Every short code of the title, each an anchor. */
+const titleWritings = (title: SubjectCodeInput["title"]): CodeWriting[] =>
+  title === undefined
+    ? []
+    : shortCodes(title.text).map((match) => ({
+        offset: title.start + match.index,
+        written: match[0],
+        characters: charactersOf(match[0]),
+        label: TITLE_GROUP,
+        anchor: true,
+        group: undefined,
+      }));
+
+/** Every short code of the prose, as an anchor when a field line of a listed kind labels it. */
+const proseWritings = (text: string, input: SubjectCodeInput): CodeWriting[] =>
+  shortCodes(text).map((match) => {
+    const written = match[0];
+    const offset = match.index;
+    const label = labelBefore(text, offset, input.labels);
+    const group = label !== undefined && LABEL_TO_NUMBER.test(label.between) ? label.group : undefined;
+    const onField = group !== undefined && input.listed.has(group) && isFieldLine(text, offset, written, label?.between ?? "", input.labels);
+    return { offset, written, characters: charactersOf(written), label: group ?? TITLE_GROUP, anchor: onField, group };
+  });
+
+/** The title's codes and the prose's, one writing per place. */
+const writingsOf = (text: string, input: SubjectCodeInput): CodeWriting[] => {
+  const inTitle = titleWritings(input.title);
+  return [...inTitle, ...proseWritings(text, input).filter((writing) => !inTitle.some((title) => title.offset === writing.offset))];
+};
+
+/** The writings of the document's one code with two neighbours swapped, each written once, of a listed kind or unlabelled, on a line that does not name the code itself. */
+export const subjectCodeVariants = (input: SubjectCodeInput): ReferenceVariant[] => {
+  const text = withoutUrls(input.prose);
+  const writings = writingsOf(text, input);
+  const anchors = [
+    ...writings.filter((writing) => writing.anchor),
+    ...input.tabled.filter((code) => input.listed.has(code.label) && isSubjectCode(code.written)),
+  ];
+  const subject = anchors[0];
+  if (subject === undefined || anchors.some((anchor) => anchor.characters !== subject.characters)) return [];
+  const timesWritten = (characters: string): number => writings.filter((writing) => writing.characters === characters).length;
+  return writings.flatMap((writing) => {
+    const line = lineAround(text, writing.offset);
+    const slip =
+      !writing.anchor &&
+      (writing.group === undefined || input.listed.has(writing.group)) &&
+      !input.known.has(writing.characters) &&
+      timesWritten(writing.characters) === 1 &&
+      swapsNeighbours(subject.characters, writing.characters) &&
+      !writings.some((other) => other.characters === subject.characters && other.offset >= line.start && other.offset < line.end);
+    if (!slip) return [];
+    const { offset, written, characters } = writing;
+    return [{ number: { offset, written, characters, label: subject.label }, other: subject }];
+  });
+};

package/src/unlabelled-references.ts

@@ -8,16 +8,22 @@ import { withoutEdgeMarks } from "./facts/trim-marks.ts";
 import { charactersOf, MAX_CHARACTERS, MIN_DIGITS, REFERENCE_SHAPE, type ReferenceNumber, type ReferenceVariant } from "./reference-numbers.ts";
 
 const SEPARATOR = /[-‐−－]/u;
+
+type CodeShape = (written: string) => boolean;
 const LATIN_LETTER = /[A-Z]/u;
 const DIGIT = /\d/gu;
 
-/** A code: letters, a hyphen and four digits or more (GP-0512). A plain number (48215, 2026-118) is never one. */
-const isCode = (written: string): boolean => {
-  const characters = charactersOf(written);
-  return (
-    SEPARATOR.test(written) && LATIN_LETTER.test(characters) && (characters.match(DIGIT)?.length ?? 0) >= MIN_DIGITS && characters.length <= MAX_CHARACTERS
-  );
-};
+/** A code: letters, a hyphen and the given digits or more (GP-0512). A plain number (48215, 2026-118) is never one. */
+export const isCodeWith =
+  (minDigits: number) =>
+  (written: string): boolean => {
+    const characters = charactersOf(written);
+    return (
+      SEPARATOR.test(written) && LATIN_LETTER.test(characters) && (characters.match(DIGIT)?.length ?? 0) >= minDigits && characters.length <= MAX_CHARACTERS
+    );
+  };
+
+const isCode = isCodeWith(MIN_DIGITS);
 
 const keyOf = (text: string): string => withoutEdgeMarks(text).normalize("NFKC").toLowerCase();
 
@@ -29,10 +35,10 @@ const labelOfCell = (cell: Cell | undefined, labels: readonly LexiconEntry[]): s
 };
 
 /** A cell holding one code and nothing else, as a reference number of the group. */
-const codeOfCell = (cell: Cell | undefined, group: string): ReferenceNumber[] => {
+const codeOfCell = (cell: Cell | undefined, group: string, isCodeShape: CodeShape): ReferenceNumber[] => {
   if (cell === undefined) return [];
   const written = withoutEdgeMarks(cell.text);
-  if (!isCode(written) || [...written.matchAll(REFERENCE_SHAPE)].length !== 1) return [];
+  if (!isCodeShape(written) || [...written.matchAll(REFERENCE_SHAPE)].length !== 1) return [];
   return [{ offset: cell.start + cell.text.indexOf(written), written, characters: charactersOf(written), label: group }];
 };
 
@@ -40,28 +46,30 @@ const codeOfCell = (cell: Cell | undefined, group: string): ReferenceNumber[] =>
  * The codes a table labels: in a row whose first cell is a label (| 品番 | GP-0512 |), and in a column whose heading is
  * one (| 品番 | 品名 | over | GP-0512 | …). Pass the text with its tables (proseAndTablesOf).
  */
-export const tableLabelledCodes = (text: string, labels: readonly LexiconEntry[]): ReferenceNumber[] =>
+export const tableLabelledCodes = (text: string, labels: readonly LexiconEntry[], isCodeShape: CodeShape = isCode): ReferenceNumber[] =>
   tablesOf(linesOf(text)).flatMap((table) => {
     const headings = cellsOf(table.header).map((cell) => labelOfCell(cell, labels));
     return table.rows.flatMap((row) => {
       const cells = cellsOf(row);
       const rowGroup = labelOfCell(cells[0], labels);
-      const byRow = rowGroup === undefined ? [] : codeOfCell(cells[1], rowGroup);
+      const byRow = rowGroup === undefined ? [] : codeOfCell(cells[1], rowGroup, isCodeShape);
       const byColumn = cells.flatMap((cell, index) => {
         const group = headings[index];
-        return group === undefined ? [] : codeOfCell(cell, group);
+        return group === undefined ? [] : codeOfCell(cell, group, isCodeShape);
       });
       return [...byRow, ...byColumn];
     });
   });
 
 /** The letters and digits of every code a cell holds. */
-const codesInCell = (cell: Cell): string[] =>
-  [...cell.text.matchAll(REFERENCE_SHAPE)].filter((match) => isCode(match[0])).map((match) => charactersOf(match[0]));
+const codesInCell = (cell: Cell, isCodeShape: CodeShape): string[] =>
+  [...cell.text.matchAll(REFERENCE_SHAPE)].filter((match) => isCodeShape(match[0])).map((match) => charactersOf(match[0]));
 
 /** Every code written anywhere in a table, its heading row too, labelled or not: a code a table lists is an item of its own, never a slip. */
-export const tableCodes = (text: string): Set<string> =>
-  new Set(tablesOf(linesOf(text)).flatMap((table) => [table.header, ...table.rows].flatMap((row) => cellsOf(row).flatMap(codesInCell))));
+export const tableCodes = (text: string, isCodeShape: CodeShape = isCode): Set<string> =>
+  new Set(
+    tablesOf(linesOf(text)).flatMap((table) => [table.header, ...table.rows].flatMap((row) => cellsOf(row).flatMap((cell) => codesInCell(cell, isCodeShape)))),
+  );
 
 /**
  * Every code of the prose written with no label that is one labelled code with two neighbours swapped. Only when exactly