@rudra-js/attested 0.7.4 → 0.7.6

package/src/verify.ts

@@ -12,19 +12,14 @@ export type Layer = 'quantity' | 'wording';
 
 export interface Finding {
   layer: Layer;
-
   token: string;
-
   reason: string;
 }
 
 export interface LayerReport {
   supported: boolean;
-
   strength: 'proof' | 'best-effort';
-
   checked: number;
-
   findings: Finding[];
 }
 
@@ -36,9 +31,7 @@ export interface VerifyResult {
 
 export interface Facts {
   values: readonly (string | number | bigint)[];
-
   bannedPhrases?: readonly string[];
-
   allowedPhrases?: readonly string[];
 }
 
@@ -50,50 +43,58 @@ export interface FieldResult {
 export interface BatchResult {
   supported: boolean;
   fields: FieldResult[];
-
   acrossFields: LayerReport;
 }
 
-const readings = new WeakMap<object, { held: readonly unknown[]; supported: Set<string> }>();
+const cache = new WeakMap<object, { copy: readonly unknown[]; supported: Set<string> }>();
 
-function unchanged(held: readonly unknown[], values: readonly unknown[]): boolean {
-  if (held.length !== values.length) return false;
-  for (let i = 0; i < held.length; i += 1) {
-    if (held[i] !== values[i]) return false;
+function sameValues(a: readonly unknown[], b: readonly unknown[]): boolean {
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i += 1) {
+    if (a[i] !== b[i]) return false;
   }
   return true;
 }
 
-function valuesOf(facts: Facts): Set<string> {
+function supportedOf(facts: Facts): Set<string> {
   const values = facts.values;
-
   if (!Array.isArray(values)) return supportedValues(values);
 
-  const read = readings.get(values);
-  if (read !== undefined && unchanged(read.held, values)) return read.supported;
+  const cached = cache.get(values);
+  if (cached !== undefined && sameValues(cached.copy, values)) return cached.supported;
 
   const supported = supportedValues(values);
-  readings.set(values, { held: [...values], supported });
+  cache.set(values, { copy: [...values], supported });
   return supported;
 }
 
-function phrasesOf(facts: Facts): string[] {
-  const phrases = new Set<string>(BANNED_PHRASES);
-
-  for (const phrase of facts.bannedPhrases ?? []) {
+function normaliseAll(phrases: readonly string[] | undefined): string[] {
+  const out: string[] = [];
+  for (const phrase of phrases ?? []) {
     const normalised = normalisePhrasing(phrase);
-    if (normalised.length > 0) phrases.add(normalised);
+    if (normalised.length > 0) out.push(normalised);
   }
-  return [...phrases];
+  return out;
 }
 
-function allowedOf(facts: Facts): string[] {
-  const allowed: string[] = [];
-  for (const phrase of facts.allowedPhrases ?? []) {
-    const normalised = normalisePhrasing(phrase);
-    if (normalised.length > 0) allowed.push(normalised);
-  }
-  return allowed;
+function bannedOf(facts: Facts): string[] {
+  const banned = new Set(BANNED_PHRASES);
+  for (const phrase of normaliseAll(facts.bannedPhrases)) banned.add(phrase);
+  return [...banned];
+}
+
+interface PreparedFacts {
+  supported: Set<string>;
+  banned: string[];
+  allowed: string[];
+}
+
+function readFacts(facts: Facts): PreparedFacts {
+  return {
+    supported: supportedOf(facts),
+    banned: bannedOf(facts),
+    allowed: normaliseAll(facts.allowedPhrases),
+  };
 }
 
 function reasonFor(numeral: Numeral): string {
@@ -112,11 +113,8 @@ function checkQuantities(text: string, supported: Set<string>): LayerReport {
   const reported = new Set<string>();
 
   for (const numeral of numerals) {
-    let backed = false;
-    for (const form of numeral.forms) {
-      if (supported.has(form)) backed = true;
-    }
-    if (backed || reported.has(numeral.token)) continue;
+    if (numeral.forms.some((form) => supported.has(form))) continue;
+    if (reported.has(numeral.token)) continue;
 
     reported.add(numeral.token);
     findings.push({ layer: 'quantity', token: numeral.token, reason: reasonFor(numeral) });
@@ -130,40 +128,46 @@ function checkQuantities(text: string, supported: Set<string>): LayerReport {
   };
 }
 
-function standsBehind(allowed: Span[], hit: Span): boolean {
-  for (const span of allowed) {
+function isInside(spans: Span[], hit: Span): boolean {
+  for (const span of spans) {
     if (span.start <= hit.start && hit.end <= span.end) return true;
   }
   return false;
 }
 
-function checkWording(text: string, phrases: string[], allowed: string[]): LayerReport {
-  // Read twice, since Ν reads as N but ν as v; both readings are the same length, so spans line up.
-  const texts = [normalisePhrasing(text)];
-  const byLook = normalisePhrasing(text, true);
-  if (byLook !== texts[0]) texts.push(byLook);
-
-  const scans: Indexed[] = [];
-  const spans: Span[] = [];
-  for (const normalised of texts) {
-    const indexed = indexPhrasing(normalised);
-    scans.push(indexed);
+function forgivenInEitherReading(scans: Indexed[], allowed: readonly string[]): Span[] {
+  const forgiven: Span[] = [];
+  for (const scan of scans) {
     for (const phrase of allowed) {
-      for (const span of spansIn(indexed, phrase)) {
-        if (!normalised.slice(span.start, span.end + 1).includes('\n')) spans.push(span);
+      for (const span of spansIn(scan, phrase)) {
+        if (!scan.text.slice(span.start, span.end + 1).includes('\n')) forgiven.push(span);
       }
     }
   }
+  return forgiven;
+}
 
-  const findings: Finding[] = [];
-  for (const phrase of phrases) {
-    let caught = false;
-    for (const indexed of scans) {
-      for (const hit of spansIn(indexed, phrase)) {
-        if (!standsBehind(spans, hit)) caught = true;
-      }
+function isCaught(scans: Indexed[], phrase: string, forgiven: Span[]): boolean {
+  for (const scan of scans) {
+    for (const hit of spansIn(scan, phrase)) {
+      if (!isInside(forgiven, hit)) return true;
     }
-    if (!caught) continue;
+  }
+  return false;
+}
+
+function checkWording(text: string, prepared: PreparedFacts): LayerReport {
+  const { banned, allowed } = prepared;
+  const plain = normalisePhrasing(text);
+  const byLook = normalisePhrasing(text, true);
+  const scans =
+    byLook === plain ? [indexPhrasing(plain)] : [indexPhrasing(plain), indexPhrasing(byLook)];
+
+  const forgiven = forgivenInEitherReading(scans, allowed);
+
+  const findings: Finding[] = [];
+  for (const phrase of banned) {
+    if (!isCaught(scans, phrase, forgiven)) continue;
 
     findings.push({
       layer: 'wording',
@@ -175,43 +179,35 @@ function checkWording(text: string, phrases: string[], allowed: string[]): Layer
   return {
     supported: findings.length === 0,
     strength: 'best-effort',
-    checked: phrases.length,
+    checked: banned.length,
     findings,
   };
 }
 
-function check(
-  text: string,
-  supported: Set<string>,
-  phrases: string[],
-  allowed: string[],
-): VerifyResult {
-  const quantity = checkQuantities(text, supported);
-  const wording = checkWording(text, phrases, allowed);
+function check(text: string, prepared: PreparedFacts): VerifyResult {
+  const quantity = checkQuantities(text, prepared.supported);
+  const wording = checkWording(text, prepared);
   return { supported: quantity.supported && wording.supported, quantity, wording };
 }
 
 export function verify(text: string, facts: Facts): VerifyResult {
-  return check(text, valuesOf(facts), phrasesOf(facts), allowedOf(facts));
+  return check(text, readFacts(facts));
 }
 
 export function verifyFields(fields: Record<string, string>, facts: Facts): BatchResult {
-  const supported = valuesOf(facts);
-  const phrases = phrasesOf(facts);
-  const allowed = allowedOf(facts);
+  const prepared = readFacts(facts);
 
   const results: FieldResult[] = [];
-  const written: string[] = [];
+  const texts: string[] = [];
   let allSupported = true;
   for (const field of Object.keys(fields)) {
     const text = fields[field] ?? '';
-    const result = check(text, supported, phrases, allowed);
+    const result = check(text, prepared);
     if (!result.supported) allSupported = false;
     results.push({ field, result });
-    written.push(text);
+    texts.push(text);
   }
 
-  const acrossFields = checkWording(written.join(' '), phrases, allowed);
-
+  const acrossFields = checkWording(texts.join(' '), prepared);
   return { supported: allSupported && acrossFields.supported, fields: results, acrossFields };
 }