slopless 0.2.24 → 0.2.26

package/dist/rules/syntactic-patterns/contrast/private/temporal-reframe.js

@@ -0,0 +1,318 @@
+import { wordTokens } from "../../../../shared/text/tokens.js";
+const ABSTRACT_CATEGORY_HEADS = new Set([
+    "acquisition",
+    "administration",
+    "advertising",
+    "analytics",
+    "answer",
+    "automation",
+    "awareness",
+    "brand",
+    "channel",
+    "commerce",
+    "compliance",
+    "content",
+    "control",
+    "conversion",
+    "copy",
+    "decision",
+    "delivery",
+    "demand",
+    "discoverability",
+    "discovery",
+    "distribution",
+    "documentation",
+    "editorial",
+    "enablement",
+    "engagement",
+    "execution",
+    "experience",
+    "governance",
+    "growth",
+    "hygiene",
+    "implementation",
+    "indexing",
+    "infrastructure",
+    "management",
+    "maintenance",
+    "market",
+    "marketing",
+    "media",
+    "merchandising",
+    "operations",
+    "optimization",
+    "page",
+    "plumbing",
+    "policy",
+    "positioning",
+    "procurement",
+    "product",
+    "production",
+    "publishing",
+    "ranking",
+    "recommendation",
+    "regulation",
+    "reporting",
+    "retrieval",
+    "retention",
+    "revenue",
+    "risk",
+    "sales",
+    "search",
+    "security",
+    "service",
+    "sourcing",
+    "storefront",
+    "strategy",
+    "support",
+    "trust",
+    "visibility",
+    "workflow",
+    "work"
+]);
+const ARTICLES = new Set(["a", "an", "the"]);
+const PRESENT_COPULAS = new Set(["am", "are", "is"]);
+const CONTRACTED_COPULAS = new Map([
+    ["i'm", { copula: "am", subject: ["i"] }],
+    ["you're", { copula: "are", subject: ["you"] }],
+    ["we're", { copula: "are", subject: ["we"] }],
+    ["they're", { copula: "are", subject: ["they"] }],
+    ["he's", { copula: "is", subject: ["he"] }],
+    ["she's", { copula: "is", subject: ["she"] }],
+    ["it's", { copula: "is", subject: ["it"] }],
+    ["that's", { copula: "is", subject: ["that"] }]
+]);
+const PRONOUNS = new Set([
+    "he",
+    "i",
+    "it",
+    "she",
+    "that",
+    "they",
+    "this",
+    "we",
+    "you"
+]);
+const PLURAL_PRONOUNS = new Set(["they", "we", "you"]);
+const SINGULAR_S_SUBJECTS = new Set([
+    "analytics",
+    "business",
+    "economics",
+    "logistics",
+    "news",
+    "operations",
+    "sales"
+]);
+const FACTUAL_CONNECTORS = new Set([
+    "after",
+    "although",
+    "because",
+    "before",
+    "if",
+    "since",
+    "therefore",
+    "until",
+    "when",
+    "while"
+]);
+const DETAIL_PREPOSITIONS = new Set([
+    "above",
+    "at",
+    "behind",
+    "below",
+    "beside",
+    "between",
+    "by",
+    "from",
+    "in",
+    "inside",
+    "into",
+    "near",
+    "of",
+    "on",
+    "outside",
+    "through",
+    "to",
+    "under",
+    "with",
+    "within"
+]);
+const PHYSICAL_PROPERTY_WORDS = new Set([
+    "blue",
+    "cold",
+    "dry",
+    "empty",
+    "full",
+    "green",
+    "heavy",
+    "hot",
+    "large",
+    "light",
+    "local",
+    "long",
+    "optional",
+    "red",
+    "required",
+    "shared",
+    "short",
+    "small",
+    "tall",
+    "warm",
+    "weekly",
+    "wet",
+    "wide"
+]);
+const FRAME_SUBJECTS = new Set([
+    "audit",
+    "content",
+    "data",
+    "feed",
+    "index",
+    "indexing",
+    "metadata",
+    "page",
+    "product",
+    "search",
+    "seo",
+    "visibility"
+]);
+function isCompleteSentence(text) {
+    return [".", "!", "?"].includes(text.trim().at(-1) ?? "");
+}
+function isLetter(character) {
+    return (character.toLocaleLowerCase("en") !== character.toLocaleUpperCase("en"));
+}
+function isInteriorApostrophe(text, index) {
+    return isLetter(text[index - 1] ?? "") && isLetter(text[index + 1] ?? "");
+}
+function hasQuotedValueOrNumber(text) {
+    for (let index = 0; index < text.length; index += 1) {
+        const character = text[index] ?? "";
+        if ((character >= "0" && character <= "9") ||
+            ['"', "`", "\u201c", "\u201d"].includes(character)) {
+            return true;
+        }
+        if (["'", "\u2018", "\u2019"].includes(character) &&
+            !isInteriorApostrophe(text, index)) {
+            return true;
+        }
+    }
+    return false;
+}
+function withoutArticle(words) {
+    return ARTICLES.has(words[0] ?? "") ? words.slice(1) : words;
+}
+function parsePastClause(text) {
+    const words = wordTokens(text).map((token) => token.normalized);
+    const usedIndex = words.findIndex((word, index) => word === "used" && words[index + 1] === "to" && words[index + 2] === "be");
+    const subject = words.slice(0, usedIndex);
+    const label = withoutArticle(words.slice(usedIndex + 3));
+    return usedIndex > 0 &&
+        subject.length <= 4 &&
+        label.length > 0 &&
+        label.length <= 4
+        ? { label, subject }
+        : undefined;
+}
+function parsePresentClause(text) {
+    const words = wordTokens(text).map((token) => token.normalized);
+    const start = words[0] === "now" ? 1 : 0;
+    const contracted = CONTRACTED_COPULAS.get(words[start] ?? "");
+    if (contracted !== undefined) {
+        const label = withoutArticle(words.slice(start + 1));
+        return label.length > 0 && label.length <= 4
+            ? { ...contracted, label }
+            : undefined;
+    }
+    const copulaIndex = words.findIndex((word, index) => index >= start && PRESENT_COPULAS.has(word));
+    const copula = words[copulaIndex];
+    const subject = words.slice(start, copulaIndex);
+    const label = withoutArticle(words.slice(copulaIndex + 1));
+    return copulaIndex > start &&
+        copula !== undefined &&
+        subject.length <= 4 &&
+        label.length > 0 &&
+        label.length <= 4
+        ? { copula, label, subject }
+        : undefined;
+}
+function sameSubjectOrPronoun(first, second) {
+    if (first.length === second.length &&
+        first.every((word, index) => word === second[index])) {
+        return true;
+    }
+    if (second.length !== 1 || !PRONOUNS.has(second[0] ?? "")) {
+        return false;
+    }
+    const firstPronoun = first.length === 1 ? first[0] : undefined;
+    if (firstPronoun !== undefined && PRONOUNS.has(firstPronoun)) {
+        return firstPronoun === second[0];
+    }
+    const subjectHead = first.at(-1) ?? "";
+    const pluralSubject = isPluralSubjectHead(subjectHead);
+    return pluralSubject
+        ? second[0] === "they"
+        : ["it", "that", "this"].includes(second[0] ?? "");
+}
+function isPluralSubjectHead(head) {
+    return (head.endsWith("s") && !head.endsWith("ss") && !SINGULAR_S_SUBJECTS.has(head));
+}
+function hasCopulaAgreement(clause) {
+    const subject = clause.subject;
+    const copula = clause.copula;
+    if (copula === undefined) {
+        return false;
+    }
+    if (subject.length === 1 && PRONOUNS.has(subject[0] ?? "")) {
+        if (subject[0] === "i") {
+            return copula === "am";
+        }
+        return PLURAL_PRONOUNS.has(subject[0] ?? "")
+            ? copula === "are"
+            : copula === "is";
+    }
+    const head = subject.at(-1) ?? "";
+    const plural = isPluralSubjectHead(head);
+    return copula === (plural ? "are" : "is");
+}
+function isAbstractLabel(label) {
+    return ABSTRACT_CATEGORY_HEADS.has(label.at(-1) ?? "");
+}
+function hasBlockedDetail(words) {
+    return words.some((word) => FACTUAL_CONNECTORS.has(word) ||
+        DETAIL_PREPOSITIONS.has(word) ||
+        PHYSICAL_PROPERTY_WORDS.has(word));
+}
+function isPassiveLabel(label) {
+    const head = label[0] ?? "";
+    return head.endsWith("ed") || head.endsWith("en");
+}
+function isFrameSubject(subject) {
+    const head = subject.at(-1) ?? "";
+    return (FRAME_SUBJECTS.has(head) ||
+        (subject.length === 1 && ["it", "that", "this"].includes(head)));
+}
+export function matchTemporalReframe(first, second) {
+    if (!isCompleteSentence(first) ||
+        !isCompleteSentence(second) ||
+        hasQuotedValueOrNumber(first) ||
+        hasQuotedValueOrNumber(second)) {
+        return undefined;
+    }
+    const past = parsePastClause(first);
+    const present = parsePresentClause(second);
+    if (past === undefined || present === undefined) {
+        return undefined;
+    }
+    const allWords = [...past.subject, ...past.label, ...present.label];
+    return sameSubjectOrPronoun(past.subject, present.subject) &&
+        isFrameSubject(past.subject) &&
+        hasCopulaAgreement(present) &&
+        (isAbstractLabel(past.label) || isAbstractLabel(present.label)) &&
+        !hasBlockedDetail(allWords) &&
+        !isPassiveLabel(past.label) &&
+        !isPassiveLabel(present.label)
+        ? `${first} ${second}`
+        : undefined;
+}
+//# sourceMappingURL=temporal-reframe.js.map

package/dist/rules/syntactic-patterns/lead-ins/generic-signposting.js

@@ -1,7 +1,12 @@
+import { defineTextlintRule } from "../../../adapters/textlint/rule.js";
+import { paragraphUnits, sentenceUnits } from "../../../adapters/textlint/units.js";
 import { hasConcreteImplementationSummary } from "../../../shared/matchers/concrete-evidence.js";
 import { cleanSentence, containsAny, tokens } from "../../../shared/matchers/prose-patterns.js";
-import { oneToOneRule } from "../../private/textlint-rule-builders.js";
-import { isAbstractAuditFrame, matchDiscourseEvaluationFrame, matchExpandedDiscourseFrame } from "./private/discourse-evaluation.js";
+import { splitSentences } from "../../../shared/text/sentences.js";
+import { matchComponentAssignmentFrame } from "./private/component-assignment-frame.js";
+import { isAbstractAuditFrame, matchReactionFrame, matchDiscourseEvaluationFrame, matchExpandedDiscourseFrame } from "./private/discourse-evaluation.js";
+import { matchEvaluativeColonFrame } from "./private/evaluative-colon-frame.js";
+import { matchRelativeDiscourseFrame } from "./private/relative-discourse-frame.js";
 const PREFIXES = ["however, ", "but ", "and ", "so "];
 // "as such" was removed: it is a normal anaphoric connective ("a registered adviser; as
 // such, it must...") and was the dominant false positive, not a signposting frame.
@@ -87,6 +92,19 @@ const WHAT_FRAME_TAIL_STARTERS = [
     "true",
     "usually"
 ];
+const WHAT_MATTERS_CLAUSE_STARTERS = [
+    "how",
+    "if",
+    "that",
+    "what",
+    "when",
+    "where",
+    "whether",
+    "which",
+    "who",
+    "whose",
+    "why"
+];
 const POINT_NOUNS = ["goal", "job", "key", "point", "takeaway", "trick"];
 function matchModifiedAbstractFrame(words) {
     const [first, second, third, fourth] = words;
@@ -123,7 +141,8 @@ function matchWhatFrame(words) {
             second === "changes") &&
         third === "is" &&
         fourth !== undefined &&
-        WHAT_FRAME_TAIL_STARTERS.includes(fourth)) {
+        (WHAT_FRAME_TAIL_STARTERS.includes(fourth) ||
+            (second === "matters" && !WHAT_MATTERS_CLAUSE_STARTERS.includes(fourth)))) {
         return `what-${second}-is`;
     }
     if (first === "what" && second === "matters" && third === "most") {
@@ -139,11 +158,13 @@ function matchWhatFrame(words) {
 }
 function matchAbstractFrame(text) {
     const words = tokens(text);
-    return (matchExpandedDiscourseFrame(words) ??
+    return (matchRelativeDiscourseFrame(text, words) ??
+        matchExpandedDiscourseFrame(words) ??
         matchModifiedAbstractFrame(words) ??
         matchDiscourseEvaluationFrame(words) ??
         matchPointIsToFrame(words) ??
-        matchWhatFrame(words));
+        matchWhatFrame(words) ??
+        matchReactionFrame(words));
 }
 function matchFormulaicContentSetup(text) {
     if (text.startsWith("each ") &&
@@ -198,7 +219,10 @@ function matchSignposting(sentence) {
         : stripped);
     const formulaicSetup = matchFormulaicContentSetup(stripped);
     const generatedFormula = matchGeneratedFormula(stripped);
-    if (abstract !== undefined && !concreteImplementation) {
+    if (abstract !== undefined &&
+        (abstract === "what-matters-is" ||
+            abstract.startsWith("relative-") ||
+            !concreteImplementation)) {
         return { kind: "abstract-evaluation-frame", signal: abstract };
     }
     if (generatedFormula !== undefined && !concreteImplementation) {
@@ -233,24 +257,63 @@ function matchSignposting(sentence) {
     }
     return undefined;
 }
-const rule = oneToOneRule({
-    detect: (unit) => {
-        const matched = matchSignposting(unit.text);
-        if (matched === undefined) {
-            return [];
-        }
-        return [
-            {
-                evidence: matched.signal,
-                label: matched.kind,
-                range: { start: 0, end: unit.text.length }
-            }
-        ];
+const rule = defineTextlintRule({
+    detector: {
+        detect: ({ units }) => {
+            const detections = units.flatMap((unit) => {
+                if (unit.kind === "paragraph") {
+                    const sentences = splitSentences(unit.text);
+                    const pairDetections = [];
+                    for (let index = 0; index < sentences.length - 1; index += 1) {
+                        const current = sentences[index];
+                        const next = sentences[index + 1];
+                        if (current === undefined || next === undefined) {
+                            continue;
+                        }
+                        const signal = matchComponentAssignmentFrame(current.text, next.text);
+                        if (signal !== undefined) {
+                            pairDetections.push({
+                                evidence: signal,
+                                label: "component-assignment-frame",
+                                range: { start: current.start, end: next.end },
+                                ruleId: "syntactic-patterns:generic-signposting",
+                                unitId: unit.id
+                            });
+                        }
+                    }
+                    return pairDetections;
+                }
+                const componentSignal = matchComponentAssignmentFrame(unit.text);
+                const colonSignal = matchEvaluativeColonFrame(unit.text);
+                const matched = componentSignal === undefined && colonSignal === undefined
+                    ? matchSignposting(unit.text)
+                    : undefined;
+                const signal = componentSignal ?? colonSignal ?? matched?.signal;
+                if (signal === undefined) {
+                    return [];
+                }
+                return [
+                    {
+                        evidence: signal,
+                        label: componentSignal !== undefined
+                            ? "component-assignment-frame"
+                            : colonSignal !== undefined
+                                ? "evaluative-colon-frame"
+                                : (matched?.kind ?? "generic-signposting"),
+                        range: { start: 0, end: unit.text.length },
+                        ruleId: "syntactic-patterns:generic-signposting",
+                        unitId: unit.id
+                    }
+                ];
+            });
+            return detections;
+        },
+        family: "syntactic-patterns",
+        id: "syntactic-patterns:generic-signposting"
     },
-    family: "syntactic-patterns",
     formatMessage: (report) => `Generic signposting found: ${report.evidence}. Replace the frame with the concrete claim.`,
-    ruleId: "syntactic-patterns:generic-signposting",
-    unitKind: "sentence"
+    reportPolicy: { kind: "one-to-one" },
+    units: (document) => [...sentenceUnits(document), ...paragraphUnits(document)]
 });
 export default rule;
 //# sourceMappingURL=generic-signposting.js.map