@starci/hfs 4.11.22 → 4.12.0

package/runtime/scripts/hfs/rules/text-integrity.d.mts

@@ -0,0 +1,9 @@
+import type { Repo } from './rule-types.mjs';
+export declare const HFS_TEXT_CORRUPT = "HFS_TEXT_CORRUPT";
+/** Corrupted Vietnamese copy in the message catalogs of this root/side scope. */
+export declare function textIntegrityFindings({ repoRoot, files, repo, inScope }: {
+    repoRoot: string;
+    files: string[];
+    repo: Repo;
+    inScope?: (file: string) => boolean;
+}): import("./rule-types.mjs").Finding[];

package/runtime/scripts/hfs/rules/text-integrity.mjs

@@ -2,7 +2,6 @@
 // is valid UTF-8, and no `vi` string carries the mark of a lossy re-encode: a diacritic letter replaced by a literal `?`
 // (so a word reads as letters around a question mark) or by the U+FFFD replacement character.
 import { found, readText } from './read.mjs';
-
 export const HFS_TEXT_CORRUPT = 'HFS_TEXT_CORRUPT';
 const CATALOG_TS_SUFFIX = '.messages.ts';
 const CATALOG_JSON = /(?:^|\/)vi\.json$/;
@@ -11,63 +10,68 @@ const REPLACEMENT = '\uFFFD';
 // A `?` between letters, doubled, or closing a word before punctuation is a lost diacritic; a sentence-final "?" and a lone "?" are not.
 const LOST_LETTER = /\p{L}\?(?=[\p{L}?])|\?\?|\p{L}\?(?=[.,;:)])|(?:^|[\s("])\?\p{L}/u;
 const STRING_LITERAL = /"((?:[^"\\\n]|\\.)*)"/g;
-
 function lineOf(text, index) {
-  return text.slice(0, index).split('\n').length;
+    return text.slice(0, index).split('\n').length;
 }
-
 // The text of the `vi:` map of a catalog bundle: from `vi:` to the first closing brace at the bundle's own indent.
 function viBlocks(text) {
-  const blocks = [];
-  for (const start of text.matchAll(/\bvi:\s*\{/g)) {
-    const from = start.index + start[0].length;
-    const end = text.indexOf('\n    }', from);
-    blocks.push({ from, to: end < 0 ? text.length : end });
-  }
-  return blocks;
+    const blocks = [];
+    for (const start of text.matchAll(/\bvi:\s*\{/g)) {
+        const from = start.index + start[0].length;
+        const end = text.indexOf('\n    }', from);
+        blocks.push({ from, to: end < 0 ? text.length : end });
+    }
+    return blocks;
 }
-
 function jsonStrings(node, out) {
-  if (typeof node === 'string') out.push(node);
-  else if (node && typeof node === 'object') for (const value of Object.values(node)) jsonStrings(value, out);
+    if (typeof node === 'string')
+        out.push(node);
+    else if (node && typeof node === 'object')
+        for (const value of Object.values(node))
+            jsonStrings(value, out);
 }
-
 function corruptLine(file, line, value) {
-  return found(HFS_TEXT_CORRUPT, file, `${file}:${line} Vietnamese text ${JSON.stringify(value)} lost its diacritics (a "?" or U+FFFD stands for a letter); rewrite the file as UTF-8 with an editor or Node, never a shell pipe`, { line });
+    return found(HFS_TEXT_CORRUPT, file, `${file}:${line} Vietnamese text ${JSON.stringify(value)} lost its diacritics (a "?" or U+FFFD stands for a letter); rewrite the file as UTF-8 with an editor or Node, never a shell pipe`, { line });
 }
-
 function tsFindings(file, text) {
-  const findings = [];
-  for (const { from, to } of viBlocks(text)) {
-    for (const literal of text.slice(from, to).matchAll(STRING_LITERAL)) {
-      if (LOST_LETTER.test(literal[1])) findings.push(corruptLine(file, lineOf(text, from + literal.index), literal[1]));
+    const findings = [];
+    for (const { from, to } of viBlocks(text)) {
+        for (const literal of text.slice(from, to).matchAll(STRING_LITERAL)) {
+            if (LOST_LETTER.test(literal[1]))
+                findings.push(corruptLine(file, lineOf(text, from + literal.index), literal[1]));
+        }
     }
-  }
-  return findings;
+    return findings;
 }
-
 function jsonFindings(file, text) {
-  let doc;
-  try { doc = JSON.parse(text); } catch { return []; }
-  const strings = [];
-  jsonStrings(doc, strings);
-  return strings.filter((value) => LOST_LETTER.test(value)).map((value) => corruptLine(file, lineOf(text, text.indexOf(value)), value));
+    let doc;
+    try {
+        doc = JSON.parse(text);
+    }
+    catch {
+        return [];
+    }
+    const strings = [];
+    jsonStrings(doc, strings);
+    return strings.filter((value) => LOST_LETTER.test(value)).map((value) => corruptLine(file, lineOf(text, text.indexOf(value)), value));
 }
-
 /** Corrupted Vietnamese copy in the message catalogs of this root/side scope. */
 export function textIntegrityFindings({ repoRoot, files, repo, inScope = () => true }) {
-  if (repo.kind === 'runtime' || !['lite', 'full'].includes(repo.edition ?? 'full')) return [];
-  const findings = [];
-  for (const file of files) {
-    const ts = file.endsWith(CATALOG_TS_SUFFIX);
-    if (!inScope(file) || OUTSIDE.test(file) || !(ts || CATALOG_JSON.test(file))) continue;
-    const text = readText(repoRoot, file);
-    if (text === null) continue;
-    if (text.includes(REPLACEMENT)) {
-      findings.push(found(HFS_TEXT_CORRUPT, file, `${file}:${lineOf(text, text.indexOf(REPLACEMENT))} is not valid UTF-8 (it holds U+FFFD); rewrite the file as UTF-8 with an editor or Node`, { line: lineOf(text, text.indexOf(REPLACEMENT)) }));
-      continue;
+    if (repo.kind === 'runtime' || !['lite', 'full'].includes(repo.edition ?? 'full'))
+        return [];
+    const findings = [];
+    for (const file of files) {
+        const ts = file.endsWith(CATALOG_TS_SUFFIX);
+        if (!inScope(file) || OUTSIDE.test(file) || !(ts || CATALOG_JSON.test(file)))
+            continue;
+        const text = readText(repoRoot, file);
+        if (text === null)
+            continue;
+        if (text.includes(REPLACEMENT)) {
+            findings.push(found(HFS_TEXT_CORRUPT, file, `${file}:${lineOf(text, text.indexOf(REPLACEMENT))} is not valid UTF-8 (it holds U+FFFD); rewrite the file as UTF-8 with an editor or Node`, { line: lineOf(text, text.indexOf(REPLACEMENT)) }));
+            continue;
+        }
+        findings.push(...(ts ? tsFindings(file, text) : jsonFindings(file, text)));
     }
-    findings.push(...(ts ? tsFindings(file, text) : jsonFindings(file, text)));
-  }
-  return findings;
+    return findings;
 }

package/runtime/scripts/hfs/rules/unused-symbol-flow.d.mts

@@ -0,0 +1,22 @@
+import type { Parsed, Ts } from './rule-types.mjs';
+/** A forwarded parameter must retain its value, including in a conditional guard. */
+export declare function writesBinding(state: Parsed, node: Parsed, symbol: Parsed): boolean;
+export declare const symbolAt: (state: Parsed, node: Parsed) => any;
+/**
+ * Every declaration a source assigns to (`=`, compound assignment, `++`/`--`, for-in/of, destructuring targets): one walk per source,
+ * so a member's "is it ever written" is a lookup instead of a scan of the whole tree.
+ */
+export declare function writtenDeclarations(state: Parsed, sources: Parsed): Set<unknown>;
+/** Local callable declarations and supported class fields share the same declaration resolution. */
+export declare function callableValue(state: Parsed, node: Parsed): any;
+/** Selected initializers retain their declaration identity for exact catalog consumption. */
+export declare function propertyInitializers(state: Parsed, expression: Parsed, name: string): any;
+/** Separate unbound generic receivers from receivers whose observed producers failed namespace resolution. */
+export declare function receiverBinding(state: Parsed, expression: Parsed): {
+    handedIn: any;
+    observed: any;
+};
+/** Leaf expressions `expression` may evaluate to. A translator variable and any unresolvable expression is its own leaf. */
+export declare function valuesOf(state: Parsed, expression: Parsed, visited?: Set<unknown>): Parsed;
+/** The expressions a function returns: its expression body, or the operand of each return outside nested functions. */
+export declare function returnedExpressions(ts: Ts, fn: Parsed): any[];