slopless 0.2.23 → 0.2.25

package/dist/rules/syntactic-patterns/lead-ins/private/evaluative-colon-frame.js

@@ -0,0 +1,166 @@
+import { hasConcreteTechnicalToken } from "../../../../shared/matchers/concrete-evidence.js";
+import { tokens } from "../../../../shared/matchers/prose-patterns.js";
+import { normalizeForMatch } from "../../../../shared/text/normalize.js";
+const SUBJECT_HEADS = new Set([
+    "answer",
+    "answers",
+    "approach",
+    "approaches",
+    "architecture",
+    "architectures",
+    "audit",
+    "audits",
+    "choice",
+    "choices",
+    "decision",
+    "decisions",
+    "design",
+    "designs",
+    "machine",
+    "machines",
+    "method",
+    "methods",
+    "model",
+    "models",
+    "pipeline",
+    "pipelines",
+    "plan",
+    "plans",
+    "platform",
+    "platforms",
+    "problem",
+    "problems",
+    "process",
+    "processes",
+    "solution",
+    "solutions",
+    "stack",
+    "stacks",
+    "strategy",
+    "strategies",
+    "setup",
+    "setups",
+    "system",
+    "systems",
+    "workflow",
+    "workflows"
+]);
+const EVALUATIVE_ADJECTIVES = new Set([
+    "boring",
+    "clear",
+    "complex",
+    "easy",
+    "hard",
+    "heavy",
+    "obvious",
+    "simple",
+    "straightforward"
+]);
+const EVALUATIVE_LINKS = new Set([
+    "are",
+    "feel",
+    "feels",
+    "is",
+    "look",
+    "looks",
+    "was",
+    "were"
+]);
+const QUANTITY_WORDS = new Set([
+    "one",
+    "two",
+    "three",
+    "four",
+    "five",
+    "six",
+    "seven",
+    "eight",
+    "nine",
+    "ten",
+    "dozen",
+    "hundred",
+    "thousand",
+    "million",
+    "several"
+]);
+const MONTHS_AND_TIMES = new Set([
+    "january",
+    "february",
+    "march",
+    "april",
+    "may",
+    "june",
+    "july",
+    "august",
+    "september",
+    "october",
+    "november",
+    "december",
+    "midnight",
+    "noon"
+]);
+function hasDigitOrEquationSymbol(text) {
+    for (const character of text) {
+        if ((character >= "0" && character <= "9") ||
+            ["=", "<", ">", "+", "\u00d7", "\u00f7"].includes(character)) {
+            return true;
+        }
+    }
+    return false;
+}
+function firstAsciiWord(text) {
+    let word = "";
+    for (const character of text.trimStart()) {
+        const isLetter = (character >= "A" && character <= "Z") ||
+            (character >= "a" && character <= "z");
+        const isWordContinuation = isLetter || (character >= "0" && character <= "9") || character === "-";
+        if (!isWordContinuation) {
+            break;
+        }
+        word += character;
+    }
+    return word.length > 0 ? word : undefined;
+}
+function isIdentifierLike(word) {
+    for (const character of word.slice(1)) {
+        if (character >= "A" && character <= "Z") {
+            return true;
+        }
+    }
+    return false;
+}
+function hasExcludedEvidence(text, words) {
+    const trimmed = text.trimStart();
+    const firstWord = firstAsciiWord(trimmed);
+    const startsWithNamedTechnicalSubject = firstWord !== undefined &&
+        isIdentifierLike(firstWord) &&
+        hasConcreteTechnicalToken(text);
+    return (hasDigitOrEquationSymbol(text) ||
+        trimmed.startsWith('"') ||
+        trimmed.startsWith("'") ||
+        text.includes("`") ||
+        startsWithNamedTechnicalSubject ||
+        words.some((word) => QUANTITY_WORDS.has(word) || MONTHS_AND_TIMES.has(word)));
+}
+export function matchEvaluativeColonFrame(text) {
+    const colonIndex = text.indexOf(":");
+    if (colonIndex < 0 || text.indexOf(":", colonIndex + 1) >= 0) {
+        return undefined;
+    }
+    const prefix = normalizeForMatch(text.slice(0, colonIndex));
+    const detail = text.slice(colonIndex + 1);
+    const prefixWords = tokens(prefix);
+    const detailWords = tokens(detail);
+    const copulaIndex = prefixWords.findIndex((word) => EVALUATIVE_LINKS.has(word));
+    if (copulaIndex < 1 ||
+        copulaIndex > 3 ||
+        prefixWords.length !== copulaIndex + 2 ||
+        !SUBJECT_HEADS.has(prefixWords[copulaIndex - 1] ?? "") ||
+        !EVALUATIVE_ADJECTIVES.has(prefixWords[copulaIndex + 1] ?? "") ||
+        detailWords.length < 2 ||
+        hasExcludedEvidence(detail, detailWords)) {
+        return undefined;
+    }
+    return prefixWords.join("-");
+}
+//# sourceMappingURL=evaluative-colon-frame.js.map

package/dist/rules/syntactic-patterns/lead-ins/private/reaction-frame.js

@@ -0,0 +1,29 @@
+const REACTION_NOUNS = new Set(["detail", "part", "piece", "point", "thing"]);
+const REACTION_VERBS = new Set(["got", "hit", "stuck", "surprised"]);
+export function matchReactionFrame(words) {
+    const contracted = words[0] === "here's";
+    const start = contracted || (words[0] === "here" && words[1] === "is")
+        ? contracted
+            ? 1
+            : 2
+        : -1;
+    if (start < 0 ||
+        words[start] !== "the" ||
+        !REACTION_NOUNS.has(words[start + 1] ?? "") ||
+        words[start + 2] !== "that") {
+        return undefined;
+    }
+    const verb = words[start + 3];
+    const directReaction = verb !== "stuck" &&
+        REACTION_VERBS.has(verb ?? "") &&
+        ["me", "us"].includes(words[start + 4] ?? "") &&
+        words.length === start + 5;
+    const stuckReaction = verb === "stuck" &&
+        words[start + 4] === "with" &&
+        ["me", "us"].includes(words[start + 5] ?? "") &&
+        words.length === start + 6;
+    return directReaction || stuckReaction
+        ? "here-is-the-reaction-frame"
+        : undefined;
+}
+//# sourceMappingURL=reaction-frame.js.map

package/dist/rules/syntactic-patterns/lead-ins/private/relative-discourse-frame.js

@@ -0,0 +1,119 @@
+import { tokens } from "../../../../shared/matchers/prose-patterns.js";
+const DETERMINERS = new Set(["a", "an", "the", "this", "that"]);
+const RELATIVE_FRAME_MODIFIERS = new Set([
+    "central",
+    "clearest",
+    "core",
+    "important",
+    "main",
+    "practical",
+    "real",
+    "simple",
+    "useful"
+]);
+const RELATIVE_HELPER_VERBS = new Set([
+    "helped",
+    "helps",
+    "mattered",
+    "matters",
+    "worked",
+    "works"
+]);
+const RELATIVE_USEFULNESS_ADJECTIVES = new Set([
+    "actionable",
+    "better",
+    "clear",
+    "easier",
+    "effective",
+    "helpful",
+    "practical",
+    "reliable",
+    "useful",
+    "valuable"
+]);
+const RELATIVE_EVALUATIONS = new Set([
+    "clear",
+    "consistent",
+    "predictable",
+    "repeatable",
+    "simple",
+    "straightforward",
+    "useful"
+]);
+const RELATIVE_FRAME_HEADS = new Set([
+    "answer",
+    "approach",
+    "claim",
+    "detail",
+    "evidence",
+    "factor",
+    "feature",
+    "fix",
+    "focus",
+    "idea",
+    "lesson",
+    "method",
+    "move",
+    "plan",
+    "point",
+    "process",
+    "question",
+    "result",
+    "review",
+    "rule",
+    "signal",
+    "solution",
+    "step",
+    "strategy",
+    "thing",
+    "way"
+]);
+function relativeFrameHeadIndex(words) {
+    if (!DETERMINERS.has(words[0] ?? "")) {
+        return -1;
+    }
+    if (RELATIVE_FRAME_HEADS.has(words[1] ?? "")) {
+        return 1;
+    }
+    return RELATIVE_FRAME_MODIFIERS.has(words[1] ?? "") &&
+        RELATIVE_FRAME_HEADS.has(words[2] ?? "")
+        ? 2
+        : -1;
+}
+function matchRelativeHelperFrame(text, words, headIndex) {
+    const helperIndex = headIndex + 2;
+    const colonIndex = text.indexOf(":");
+    if (words[headIndex + 1] !== "that" ||
+        !RELATIVE_HELPER_VERBS.has(words[helperIndex] ?? "") ||
+        colonIndex < 0 ||
+        tokens(text.slice(0, colonIndex)).length !== helperIndex + 1) {
+        return undefined;
+    }
+    return `relative-${words[helperIndex] ?? "helps"}-frame`;
+}
+function matchRelativeUsefulnessFrame(words, headIndex) {
+    const makesIndex = headIndex + 2;
+    if (words[headIndex + 1] !== "that" ||
+        !["made", "makes"].includes(words[makesIndex] ?? "")) {
+        return undefined;
+    }
+    const usefulnessIndex = words.findIndex((word, index) => index > makesIndex + 1 &&
+        index <= makesIndex + 6 &&
+        RELATIVE_USEFULNESS_ADJECTIVES.has(word));
+    const evaluationIndex = usefulnessIndex + 2;
+    return usefulnessIndex > 0 &&
+        ["are", "is", "was", "were"].includes(words[usefulnessIndex + 1] ?? "") &&
+        RELATIVE_EVALUATIONS.has(words[evaluationIndex] ?? "") &&
+        words.length === evaluationIndex + 1
+        ? "relative-makes-useful-evaluation"
+        : undefined;
+}
+export function matchRelativeDiscourseFrame(text, words) {
+    const headIndex = relativeFrameHeadIndex(words);
+    if (headIndex < 0) {
+        return undefined;
+    }
+    return (matchRelativeHelperFrame(text, words, headIndex) ??
+        matchRelativeUsefulnessFrame(words, headIndex));
+}
+//# sourceMappingURL=relative-discourse-frame.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "slopless",
-  "version": "0.2.23",
+  "version": "0.2.25",
   "description": "Deterministic textlint rules and CLI for catching prose slop in English Markdown.",
   "keywords": [
     "textlint",