@fsvreddit/bot-bouncer-evaluation 0.7.40

package/dist/userEvaluation/EvaluateBioTextDefinedHandles.d.ts

@@ -0,0 +1,16 @@
+import { Post } from "@devvit/public-api";
+import { CommentCreate } from "@devvit/protos";
+import { EvaluatorRegex, UserEvaluatorBase, ValidationIssue } from "./UserEvaluatorBase.js";
+import { UserExtended } from "@fsvreddit/fsv-devvit-helpers";
+export declare class EvaluateBioTextDefinedHandles extends UserEvaluatorBase {
+    name: string;
+    shortname: string;
+    banContentThreshold: number;
+    private getHandles;
+    preEvaluateComment(event: CommentCreate): boolean;
+    validateVariables(): ValidationIssue[];
+    gatherRegexes(): EvaluatorRegex[];
+    preEvaluatePost(_: Post): boolean;
+    preEvaluateUser(user: UserExtended): boolean;
+    evaluate(user: UserExtended): boolean;
+}

package/dist/userEvaluation/EvaluateBioTextDefinedHandles.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EvaluateBioTextDefinedHandles = void 0;
+const UserEvaluatorBase_js_1 = require("./UserEvaluatorBase.js");
+const lodash_1 = require("lodash");
+const regjsparser_1 = require("regjsparser");
+class EvaluateBioTextDefinedHandles extends UserEvaluatorBase_js_1.UserEvaluatorBase {
+    constructor() {
+        super(...arguments);
+        this.name = "Bio Text Defined Handle Bot";
+        this.shortname = "biotextdefinedhandles";
+        this.banContentThreshold = 0;
+    }
+    getHandles() {
+        const definedHandles = this.getModuleVariable("substitutions", "definedhandles", "");
+        if (!definedHandles) {
+            return [];
+        }
+        const parsed = (0, regjsparser_1.parse)(definedHandles, "u");
+        if (parsed.type !== "disjunction") {
+            return [];
+        }
+        return parsed.body.map(part => part.raw);
+    }
+    preEvaluateComment(event) {
+        const problematicBioText = this.gatherRegexes().map(r => r.regex);
+        return problematicBioText.some(bioText => event.author?.description && new RegExp(bioText, "u").test(event.author.description));
+    }
+    validateVariables() {
+        const results = [];
+        let regexes;
+        try {
+            regexes = this.gatherRegexes().map(r => r.regex);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : "Unknown error";
+            results.push({ severity: "error", message: `Invalid defined handles list: ${message}` });
+            return results;
+        }
+        for (const regexVal of regexes) {
+            let regex;
+            try {
+                regex = new RegExp(regexVal);
+            }
+            catch {
+                results.push({ severity: "error", message: `Invalid regex in biotextdefinedhandles: ${regexVal}` });
+                continue;
+            }
+            if (regex.test("")) {
+                results.push({ severity: "error", message: `Bio Text Defined Handles regex is too greedy: ${regexVal}` });
+            }
+        }
+        return results;
+    }
+    gatherRegexes() {
+        const prefix = this.getVariable("prefix", "");
+        const suffix = this.getVariable("suffix", "");
+        const handles = this.getHandles();
+        return (0, lodash_1.uniq)(handles.map(handle => ({
+            evaluatorName: this.name,
+            regex: `${prefix}${handle}${suffix}`,
+            flags: "u",
+        })));
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    preEvaluatePost(_) {
+        return this.getHandles().length > 0;
+    }
+    preEvaluateUser(user) {
+        if (!user.userDescription) {
+            return false;
+        }
+        const regexes = this.gatherRegexes().map(r => r.regex);
+        if (regexes.length === 0) {
+            return false;
+        }
+        if (user.commentKarma > 2000 && user.linkKarma > 2000) {
+            return false;
+        }
+        return regexes.some(bioText => user.userDescription && new RegExp(bioText, "u").test(user.userDescription));
+    }
+    evaluate(user) {
+        if (!user.userDescription) {
+            return false;
+        }
+        const regexes = this.gatherRegexes().map(r => r.regex);
+        if (regexes.length === 0) {
+            return false;
+        }
+        const bannableBioTextFound = regexes.filter(bio => user.userDescription && new RegExp(bio, "u").test(user.userDescription));
+        if (bannableBioTextFound.length === 0) {
+            return false;
+        }
+        this.canAutoBan = true;
+        this.addHitReason(`Bio text matched regexes: ${bannableBioTextFound.map(bio => `\`${bio}\``).join(", ")}`);
+        return user.nsfw || this.getPosts().some(post => post.isNsfw());
+    }
+}
+exports.EvaluateBioTextDefinedHandles = EvaluateBioTextDefinedHandles;

package/dist/userEvaluation/EvaluateBotGroupAdvanced.d.ts

@@ -0,0 +1,124 @@
+import { Comment, Post, TriggerContext, UserSocialLink } from "@devvit/public-api";
+import { CommentCreate } from "@devvit/protos";
+import { EvaluatorRegex, UserEvaluatorBase, ValidationIssue } from "./UserEvaluatorBase.js";
+import { UserExtended } from "@fsvreddit/fsv-devvit-helpers";
+interface AgeRange {
+    dateFrom: string;
+    dateTo?: string;
+}
+interface AgeInDays {
+    maxAgeInDays?: number;
+    minAgeInDays?: number;
+    maxAgeInMinutes?: number;
+    minAgeInMinutes?: number;
+}
+type AgeCriteria = AgeRange | AgeInDays;
+interface NotCondition {
+    not: CriteriaGroup;
+}
+interface EveryCondition {
+    every: CriteriaGroup[];
+}
+interface SomeCondition {
+    some: CriteriaGroup[];
+}
+interface BaseItemCondition {
+    matchesNeeded?: number;
+    distinctSubsNeeded?: number;
+    age?: AgeCriteria;
+    edited?: boolean;
+    subredditName?: string[];
+    notSubredditName?: string[];
+    bodyRegex?: string[];
+    minBodyLength?: number;
+    maxBodyLength?: number;
+    minParaCount?: number;
+    maxParaCount?: number;
+    minKarma?: number;
+    maxKarma?: number;
+}
+interface PostCondition extends BaseItemCondition {
+    type: "post";
+    pinned?: boolean;
+    titleRegex?: string[];
+    nsfw?: boolean;
+    urlRegex?: string[];
+    domain?: string[];
+    isCrossPost?: boolean;
+}
+interface CommentCondition extends BaseItemCondition {
+    type: "comment";
+    postId?: string[];
+    isTopLevel?: boolean;
+    isCommentOnOwnPost?: boolean;
+    postAuthorNameRegex?: string[];
+    postTitleRegex?: string[];
+    postBodyRegex?: string[];
+    postUrlRegex?: string[];
+    postCreatedAtAge?: AgeCriteria;
+}
+type CriteriaGroup = NotCondition | EveryCondition | SomeCondition | PostCondition | CommentCondition;
+interface BotGroup {
+    name: string;
+    submitterName?: string | string[];
+    descriptionForAI?: string;
+    usernameRegex?: string[];
+    matchesDefaultUsernameRegex?: boolean;
+    maxCommentKarma?: number;
+    maxLinkKarma?: number;
+    minCommentKarma?: number;
+    minLinkKarma?: number;
+    age?: AgeCriteria;
+    nsfw?: boolean;
+    bioRegex?: string[];
+    displayNameRegex?: string[];
+    socialLinkRegex?: string[];
+    socialLinkTitleRegex?: string[];
+    hasNoSocialLinks?: boolean;
+    hasVerifiedEmail?: boolean;
+    hasRedditPremium?: boolean;
+    isSubredditModerator?: boolean;
+    hasMoreThanOneCommentOnPosts?: boolean;
+    criteria?: CriteriaGroup;
+}
+export declare class EvaluateBotGroupAdvanced extends UserEvaluatorBase {
+    name: string;
+    shortname: string;
+    banContentThreshold: number;
+    private verboseLogging;
+    private redis;
+    allowNewFeatures: boolean;
+    private evaluationError;
+    constructor(context: TriggerContext, history: (Post | Comment)[], socialLinks: UserSocialLink[] | undefined, variables: Record<string, unknown>);
+    private anyRegexMatches;
+    getBotGroups(): BotGroup[];
+    validateVariables(): ValidationIssue[];
+    private uniqueMatchReasons;
+    private getCriteriaGroupRegexes;
+    private getBotGroupRegexes;
+    gatherRegexes(): EvaluatorRegex[];
+    getSubGroups(): string[] | undefined;
+    private matchesAgeCriteria;
+    private anySubredditMatches;
+    private postOrCommentMatchesCondition;
+    collectCommentConditionsForPreEvalation(criteria: CriteriaGroup): CommentCondition[];
+    collectNegatedCommentConditionsForPreEvaluation(criteria: CriteriaGroup): CommentCondition[];
+    preEvaluateComment(comment: CommentCreate): Promise<boolean>;
+    private postMatchesCondition;
+    private cachedPostProperties;
+    private postPropertiesStatistics;
+    private getPostProperties;
+    private commentMatchesCondition;
+    private collectPostConditionsForPreEvalation;
+    private collectNegatedPostConditionsForPreEvaluation;
+    preEvaluatePost(post: Post): Promise<boolean>;
+    private accountMatchesSocialLinkCriteria;
+    private accountMatchesGroup;
+    preEvaluateUser(user: UserExtended): Promise<boolean>;
+    private historyMatchesCriteriaGroup;
+    private logEvaluationTime;
+    private submitterName;
+    setSubmitterName(submitterName: string): void;
+    evaluate(user: UserExtended): Promise<boolean>;
+}
+export {};