hanlint 0.0.10 → 0.0.13

package/src/index.js

@@ -8,11 +8,9 @@
  * ```
  *
  * 합격과 불합격을 판정하지 않는다. 지적 목록이 비어 있다는 것은 세어서 잡히는 결함이 없다는 뜻이다.
- * 지문 지도 (audit, map) 와 프로파일은 파이썬 패키지에 있다.
+ * 같은 공개 API를 Node와 브라우저가 공유한다. 파일 경로를 읽는 API만 Node 전용이다.
  */
-import { readFileSync } from "node:fs";
-
-import { loadConfig } from "./config/loadConfig.js";
+import { readExternal } from "./data/read.js";
 import { Patch } from "./config/patch.js";
 import {
   CONTRACT_VERSION,
@@ -27,15 +25,37 @@ import {
 import { configFromMapping, defaultConfig } from "./config/settings.js";
 import { loadVersion } from "./data/load.js";
 import { parseMarkdown } from "./document/parseMarkdown.js";
+import { SOURCE_SUFFIXES, replaceLiteral, sourceLiterals } from "./document/sourceText.js";
+import { parseSheet, renderSheet, renderSheetJson } from "./report/sheet.js";
+import { headingsOf } from "./document/model.js";
 import { applyFixes } from "./edit/applyFixes.js";
 import { buildFingerprint } from "./fingerprint/build.js";
 import { fingerprintDict } from "./report/fingerprintJson.js";
 import { check, contractFromText, contractFromTextV2, verifyPatch } from "./guard/contract.js";
 import { CheckResult, PatchResult, renderCheck } from "./guard/receipt.js";
+import { compareOutline } from "./guard/outline.js";
+import { protectedSurface, surfaceDiff } from "./guard/surface.js";
 import { ruleDoc, ruleNames, ruleSummary, runAll } from "./rules/registry.js";
+import { renderJson } from "./report/jsonReport.js";
+import { learnExemplars } from "./learn/edits.js";
+import { learnOperations } from "./learn/operations.js";
+
+const nodeConfig = typeof process === "object" && process.versions?.node ? await import("./config/loadConfig.js") : null;
+
+/** Node 파일 설정. 브라우저에서는 configFromMapping에 설정 객체를 전달한다. @param {string | null} path @param {string | null} start */
+export function loadConfig(path = null, start = null) {
+  if (!nodeConfig) throw new Error("브라우저에서는 configFromMapping으로 설정 객체를 전달해 주세요.");
+  return nodeConfig.loadConfig(path, start);
+}
 
 export {
   CheckResult,
+  SOURCE_SUFFIXES,
+  parseSheet,
+  renderSheet,
+  renderSheetJson,
+  replaceLiteral,
+  sourceLiterals,
   CONTRACT_VERSION,
   CONTRACT_VERSIONS,
   Contract,
@@ -52,7 +72,6 @@ export {
   configFromMapping,
   defaultConfig,
   fingerprintDict,
-  loadConfig,
   parseContract,
   renderCheck,
   ruleDoc,
@@ -88,5 +107,33 @@ export function lintText(text, config = defaultConfig(), path = null) {
  * @param {import("./config/settings.js").Config} [config]
  */
 export function lintFile(path, config = defaultConfig()) {
-  return lintText(readFileSync(path, "utf-8"), config, path);
+  return lintText(readExternal(path), config, path);
+}
+
+/** 지적, 문체 본보기, 승인 고침과 지문을 같은 분석에서 제공한다. @param {string} text @param {import("./config/settings.js").Config} config */
+export function inspectText(text, config = defaultConfig()) {
+  const document = fingerprint(text, config);
+  const findings = runAll(document, config);
+  const path = "draft.md";
+  const report = JSON.parse(renderJson(new Map([[path, findings]]), null,
+    new Map([[path, document.register]]), config.preset, config.exemplars,
+    new Map([[path, document]]), config.patches, config.operations, config.protectedTerms));
+  return { findings, report: report.files[0], document: fingerprintDict(document) };
+}
+
+/** 사람 수정 전후에서 승인할 후보를 추출한다. 후보 자체는 승인이 아니다. @param {string} before @param {string} after @param {import("./config/settings.js").Config} config */
+export function learnText(before, after, config = defaultConfig()) {
+  const beforeDoc = fingerprint(before, config), afterDoc = fingerprint(after, config);
+  return {
+    exemplars: learnExemplars(beforeDoc, afterDoc, runAll(beforeDoc, config), runAll(afterDoc, config), config.preset),
+    operations: learnOperations(beforeDoc, afterDoc, config.preset, config.protectedTerms),
+  };
+}
+
+/** 자유 원고의 표면과 H2 순서를 비교한다. 빈 글과 반복 제목도 관찰하며 승인 계약을 만들지 않는다. @param {string} before @param {string} after @param {import("./config/settings.js").Config} config */
+export function compareRevision(before, after, config = defaultConfig()) {
+  const original = before.normalize("NFC");
+  const outline = { level: 2, headings: headingsOf(parseMarkdown(original), 2).map((heading) => heading.text) };
+  return { surface: protectedSurface(original), changes: surfaceDiff(original, after),
+    outline: compareOutline(outline, fingerprint(after, config)) };
 }

package/src/learn/edits.js

@@ -0,0 +1,31 @@
+// @ts-check
+/** Python learn/edits.py와 같은 원문 문장 대응 및 지적 소멸 후보다. */
+import { sourceSentenceTexts } from "../fingerprint/sourceSentence.js";
+import { readerKind } from "../fingerprint/readerState.js";
+import { localCue, SENTENCE } from "../rules/finding.js";
+import { changedSentencePairs } from "./pairs.js";
+
+export function learnExemplars(beforeDoc, afterDoc, beforeFindings, afterFindings, preset = null) {
+  const pairs = changedSentencePairs(beforeDoc.sentences, afterDoc.sentences);
+  const rawBefore = sourceSentenceTexts(beforeDoc), rawAfter = sourceSentenceTexts(afterDoc);
+  const remaining = new Set(afterFindings.filter((item) => item.scope === SENTENCE && item.at >= 0).map((item) => `${item.rule}:${item.at}`));
+  const beforeByIndex = new Map(beforeDoc.sentences.map((item) => [item.index, item]));
+  const seen = new Set(), learned = [];
+  for (const finding of beforeFindings) {
+    const key = `${finding.rule}:${finding.at}`;
+    if (finding.scope !== SENTENCE || finding.at < 0 || seen.has(key)) continue;
+    const after = pairs.get(finding.at), before = beforeByIndex.get(finding.at);
+    if (!after || !before || after.some((item) => remaining.has(`${finding.rule}:${item.index}`))) continue;
+    const afterPlain = after.map((item) => item.text.trim()).filter(Boolean).join(" ");
+    const afterText = after.filter((item) => item.text.trim()).map((item) => (rawAfter.get(item.index) ?? item.text).trim()).join(" ");
+    if (!afterText || before.text.trim() === afterPlain) continue;
+    seen.add(key);
+    learned.push({ rule: finding.rule, before: (rawBefore.get(before.index) ?? before.text).trim(), after: afterText,
+      moved: "실제 수정본의 문장으로 바꿈", why: finding.why, beforeLine: before.line,
+      afterLines: [...new Set(after.map((item) => item.line))], sentence: before.text.trim(),
+      cue: localCue(finding), reader: readerKind(before, beforeDoc.reader.beforeSentence[finding.at]),
+      ...(preset ? { presets: [preset] } : {}),
+    });
+  }
+  return learned;
+}

package/src/learn/operations.js

@@ -0,0 +1,28 @@
+// @ts-check
+/** Python learn/operations.py의 표면 치환 후보와 증거 묶음. */
+import { operationFromApproval } from "../data/operations.js";
+import { sourceSentenceTexts } from "../fingerprint/sourceSentence.js";
+import { changedSentencePairs } from "./pairs.js";
+
+export function learnOperations(beforeDoc, afterDoc, preset = null, protectedTerms = []) {
+  const pairs = changedSentencePairs(beforeDoc.sentences, afterDoc.sentences);
+  const rawBefore = sourceSentenceTexts(beforeDoc), rawAfter = sourceSentenceTexts(afterDoc);
+  const beforeByIndex = new Map(beforeDoc.sentences.map((item) => [item.index, item]));
+  const grouped = new Map(), presets = preset ? [preset] : [];
+  for (const [index, after] of pairs) {
+    const before = beforeByIndex.get(index);
+    if (after.length !== 1 || !before) continue;
+    const sourceBefore = (rawBefore.get(index) ?? before.text).trim();
+    const sourceAfter = (rawAfter.get(after[0].index) ?? after[0].text).trim();
+    const operation = operationFromApproval(sourceBefore, sourceAfter, presets, protectedTerms);
+    if (!operation) continue;
+    const key = JSON.stringify([operation.before, operation.after]);
+    const item = grouped.get(key) ?? { kind: "surfaceSubstitution", before: operation.before, after: operation.after, evidence: [] };
+    item.evidence.push({ sourceBefore, sourceAfter, beforeLine: before.line, afterLine: after[0].line });
+    grouped.set(key, item);
+  }
+  return [...grouped.values()].map((item) => ({ ...item, evidenceCount: item.evidence.length,
+    guards: { maximumCharacters: 32, maximumSurfaceEditDistance: 1, protectedFacts: true, uniqueWordBoundary: true },
+    ...(preset ? { presets } : {}),
+  }));
+}

package/src/learn/pairs.js

@@ -0,0 +1,57 @@
+// @ts-check
+/** Python SequenceMatcher(autojunk=False)의 문장 대응. 가장 긴 연속 일치의 앞쪽을 먼저 택한다. */
+function longest(left, right, start, end, otherStart, otherEnd) {
+  let best = [start, otherStart, 0], previous = new Map();
+  const positions = new Map();
+  for (let index = otherStart; index < otherEnd; index++) {
+    const list = positions.get(right[index]) ?? [];
+    list.push(index);
+    positions.set(right[index], list);
+  }
+  for (let index = start; index < end; index++) {
+    const current = new Map();
+    for (const other of positions.get(left[index]) ?? []) {
+      const size = (previous.get(other - 1) ?? 0) + 1;
+      current.set(other, size);
+      if (size > best[2]) best = [index - size + 1, other - size + 1, size];
+    }
+    previous = current;
+  }
+  return best;
+}
+
+/** @param {string[]} left @param {string[]} right */
+export function changedRanges(left, right) {
+  const pending = [[0, left.length, 0, right.length]], blocks = [];
+  while (pending.length) {
+    const [start, end, otherStart, otherEnd] = pending.pop();
+    const [at, other, size] = longest(left, right, start, end, otherStart, otherEnd);
+    if (!size) continue;
+    blocks.push([at, other, size]);
+    if (start < at && otherStart < other) pending.push([start, at, otherStart, other]);
+    if (at + size < end && other + size < otherEnd) pending.push([at + size, end, other + size, otherEnd]);
+  }
+  blocks.sort((a, b) => a[0] - b[0] || a[1] - b[1]);
+  blocks.push([left.length, right.length, 0]);
+  const ranges = [];
+  let start = 0, otherStart = 0;
+  for (const [at, other, size] of blocks) {
+    if (start < at || otherStart < other) ranges.push([start, at, otherStart, other]);
+    start = at + size;
+    otherStart = other + size;
+  }
+  return ranges;
+}
+
+/** 기존 Python learn의 일대일 및 한 문장 분할 대응을 그대로 따른다. */
+export function changedSentencePairs(before, after) {
+  const pairs = new Map();
+  for (const [start, end, otherStart, otherEnd] of changedRanges(before.map((item) => item.text), after.map((item) => item.text))) {
+    const count = end - start, otherCount = otherEnd - otherStart;
+    if (!count || !otherCount) continue;
+    if (count === otherCount) {
+      for (let offset = 0; offset < count; offset++) pairs.set(before[start + offset].index, [after[otherStart + offset]]);
+    } else if (count === 1) pairs.set(before[start].index, after.slice(otherStart, otherEnd));
+  }
+  return pairs;
+}

package/src/rules/registry.js

@@ -56,6 +56,9 @@ import * as headingSkip from "./structure/headingSkip.js";
 import * as headingUniform from "./structure/headingUniform.js";
 import * as introLong from "./structure/introLong.js";
 import * as sectionNoProse from "./structure/sectionNoProse.js";
+import * as screenNarration from "./screen/screenNarration.js";
+import * as screenSentence from "./screen/screenSentence.js";
+import * as screenTone from "./screen/screenTone.js";
 
 /**
  * @typedef {object} Rule
@@ -116,6 +119,9 @@ export const RULES = [
   duplicateBlock,
   firstResultDistance,
   platformApi,
+  screenNarration,
+  screenSentence,
+  screenTone,
 ];
 
 /**
@@ -192,6 +198,7 @@ export const CATEGORY_TITLES = {
   document: "두 자리를 대조해 세는 것",
   orthography: "표기와 띄어쓰기",
   code: "코드 블록 사이를 대조하는 것",
+  screen: "화면의 글에서 세는 것",
 };
 
 /** 규칙이 세는 방법. @param {string} name */

package/src/rules/screen/screenNarration.js

@@ -0,0 +1,10 @@
+// @ts-check
+import { firstMatchFindings } from "../shared/dictionaryRule.js";
+
+export const name = "screenNarration";
+export const mechanism = "dictionary";
+
+/** @param {import("../../fingerprint/build.js").DocumentPrint} doc */
+export function run(doc) {
+  return firstMatchFindings(doc, "screenNarration", name);
+}

package/src/rules/screen/screenSentence.js

@@ -0,0 +1,10 @@
+// @ts-check
+import { firstMatchFindings } from "../shared/dictionaryRule.js";
+
+export const name = "screenSentence";
+export const mechanism = "dictionary";
+
+/** @param {import("../../fingerprint/build.js").DocumentPrint} doc */
+export function run(doc) {
+  return firstMatchFindings(doc, "screenSentence", name);
+}

package/src/rules/screen/screenTone.js

@@ -0,0 +1,10 @@
+// @ts-check
+import { firstMatchFindings } from "../shared/dictionaryRule.js";
+
+export const name = "screenTone";
+export const mechanism = "dictionary";
+
+/** @param {import("../../fingerprint/build.js").DocumentPrint} doc */
+export function run(doc) {
+  return firstMatchFindings(doc, "screenTone", name);
+}

package/src/rules/shared/dictionaryRule.js

@@ -43,3 +43,33 @@ export function dictionaryFindings(doc, dictionary, ruleName, severity = ERROR)
   }
   return findings;
 }
+
+/**
+ * 문장마다 가장 앞의 매치 하나만 지적한다. 뜻은 파이썬 rules/shared/dictionaryRule.py 의 firstMatchFindings 가 소유한다.
+ * 구체 무늬와 종결어미가 한 사전에 같이 사는 화면 사전에 쓴다. fix 는 내지 않는다.
+ * @param {import("../../fingerprint/build.js").DocumentPrint} doc
+ * @param {string} dictionary
+ * @param {string} ruleName
+ * @param {string} [severity]
+ * @returns {import("../finding.js").Finding[]}
+ */
+export function firstMatchFindings(doc, dictionary, ruleName, severity = ERROR) {
+  const findings = [];
+  for (const sentence of doc.sentences) {
+    const match = sentence.matches.find((m) => m.dictionary === dictionary);
+    if (!match) continue;
+    findings.push(
+      finding(
+        ruleName,
+        sentence.line + countNewlines(sentence.text.slice(0, match.start)),
+        sentence.text,
+        `\`${match.text}\` ${match.why} (${match.source})`,
+        null,
+        severity,
+        SENTENCE,
+        sentence.index,
+      ),
+    );
+  }
+  return findings;
+}