@atcute/bluesky-moderation 2.0.4 → 3.0.1

package/lib/_test-util/moderation-behavior.ts

@@ -0,0 +1,259 @@
+import type { ComAtprotoLabelDefs } from '@atcute/atproto';
+
+import { expect } from 'vitest';
+
+import { LabelPreference, type DisplayRestrictions, type ModerationOptions } from '../index.ts';
+
+import * as m from './mock.ts';
+
+export type ModerationTestSuiteResultFlag = 'filter' | 'blur' | 'alert' | 'inform' | 'noOverride';
+
+export interface ModerationTestSuiteScenario {
+	cfg: string;
+	subject: 'post' | 'profile' | 'userlist' | 'feedgen';
+	author: string;
+	quoteAuthor?: string;
+	labels: {
+		post?: string[];
+		profile?: string[];
+		account?: string[];
+		quotedPost?: string[];
+		quotedAccount?: string[];
+	};
+	behaviors: {
+		profileList?: ModerationTestSuiteResultFlag[];
+		profileView?: ModerationTestSuiteResultFlag[];
+		profileMedia?: ModerationTestSuiteResultFlag[];
+		contentList?: ModerationTestSuiteResultFlag[];
+		contentView?: ModerationTestSuiteResultFlag[];
+		contentMedia?: ModerationTestSuiteResultFlag[];
+	};
+}
+
+export type SuiteUsers = Record<
+	string,
+	{
+		blocking: boolean;
+		blockingByList: boolean;
+		blockedBy: boolean;
+		muted: boolean;
+		mutedByList: boolean;
+	}
+>;
+
+export type SuiteConfigurations = Record<
+	string,
+	{
+		authed?: boolean;
+		adultContentEnabled?: boolean;
+		settings?: Record<string, LabelPreference>;
+	}
+>;
+
+export type SuiteScenarios = Record<string, ModerationTestSuiteScenario>;
+
+expect.extend({
+	toBeModerationResult(
+		actual: DisplayRestrictions,
+		expected: ModerationTestSuiteResultFlag[] | undefined,
+		context = '',
+		stringifiedResult: string | undefined = undefined,
+		_ignoreCause = false,
+	) {
+		const fail = (msg: string) => ({
+			pass: false,
+			message: () => `${msg}.${stringifiedResult ? ` Full result: ${stringifiedResult}` : ''}`,
+		});
+		// let cause = actual.causes?.type as string
+		// if (actual.cause?.type === 'label') {
+		//   cause = `label:${actual.cause.labelDef.id}`
+		// } else if (actual.cause?.type === 'muted') {
+		//   if (actual.cause.source.type === 'list') {
+		//     cause = 'muted-by-list'
+		//   }
+		// } else if (actual.cause?.type === 'blocking') {
+		//   if (actual.cause.source.type === 'list') {
+		//     cause = 'blocking-by-list'
+		//   }
+		// }
+		if (!expected) {
+			// if (!ignoreCause && actual.cause) {
+			//   return fail(`${context} expected to be a no-op, got ${cause}`)
+			// }
+			if (actual.informs.length > 0) {
+				return fail(`${context} expected to be a no-op, got inform=true`);
+			}
+			if (actual.alerts.length > 0) {
+				return fail(`${context} expected to be a no-op, got alert=true`);
+			}
+			if (actual.blurs.length > 0) {
+				return fail(`${context} expected to be a no-op, got blur=true`);
+			}
+			if (actual.filters.length > 0) {
+				return fail(`${context} expected to be a no-op, got filter=true`);
+			}
+			if (actual.noOverride) {
+				return fail(`${context} expected to be a no-op, got noOverride=true`);
+			}
+		} else {
+			// if (!ignoreCause && cause !== expected.cause) {
+			//   return fail(`${context} expected to be ${expected.cause}, got ${cause}`)
+			// }
+			const expectedInform = expected.includes('inform');
+			if (!!(actual.informs.length > 0) !== expectedInform) {
+				return fail(
+					`${context} expected to be inform=${expectedInform}, got ${actual.informs.length > 0 || false}`,
+				);
+			}
+			const expectedAlert = expected.includes('alert');
+			if (!!(actual.alerts.length > 0) !== expectedAlert) {
+				return fail(
+					`${context} expected to be alert=${expectedAlert}, got ${actual.alerts.length > 0 || false}`,
+				);
+			}
+			const expectedBlur = expected.includes('blur');
+			if (!!(actual.blurs.length > 0) !== expectedBlur) {
+				return fail(
+					`${context} expected to be blur=${expectedBlur}, got ${actual.blurs.length > 0 || false}`,
+				);
+			}
+			const expectedFilter = expected.includes('filter');
+			if (!!(actual.filters.length > 0) !== expectedFilter) {
+				return fail(
+					`${context} expected to be filter=${expectedFilter}, got ${actual.filters.length > 0 || false}`,
+				);
+			}
+			const expectedNoOverride = expected.includes('noOverride');
+			if (!!actual.noOverride !== expectedNoOverride) {
+				return fail(
+					`${context} expected to be noOverride=${expectedNoOverride}, got ${actual.noOverride || false}`,
+				);
+			}
+		}
+		return { pass: true, message: () => '' };
+	},
+});
+
+declare module 'vitest' {
+	// oxlint-disable-next-line no-unused-vars -- required for module augmentation
+	interface Assertion<T = any> {
+		toBeModerationResult(
+			expected?: ModerationTestSuiteResultFlag[],
+			context?: string,
+			stringifiedResult?: string,
+			ignoreCause?: boolean,
+		): void;
+	}
+
+	interface AsymmetricMatchers {
+		toBeModerationResult(
+			expected?: ModerationTestSuiteResultFlag[],
+			context?: string,
+			stringifiedResult?: string,
+			ignoreCause?: boolean,
+		): any;
+	}
+}
+
+export class ModerationBehaviorSuiteRunner {
+	users: SuiteUsers;
+	configurations: SuiteConfigurations;
+	scenarios: SuiteScenarios;
+
+	constructor(users: SuiteUsers, configurations: SuiteConfigurations, scenarios: SuiteScenarios) {
+		this.users = users;
+		this.configurations = configurations;
+		this.scenarios = scenarios;
+	}
+
+	postScenario(scenario: ModerationTestSuiteScenario) {
+		if (scenario.subject !== 'post') {
+			throw new Error('Scenario subject must be "post"');
+		}
+		const author = this.profileView(scenario.author, scenario.labels);
+		return m.postView({
+			record: m.post({
+				text: 'Post text',
+			}),
+			author,
+			labels: (scenario.labels.post || []).map((val) =>
+				m.label({ val, uri: `at://${author.did}/app.bsky.feed.post/fake` }),
+			),
+			embed: scenario.quoteAuthor
+				? m.embedRecordView({
+						record: m.post({
+							text: 'Quoted post text',
+						}),
+						labels: (scenario.labels.quotedPost || []).map((val) =>
+							m.label({
+								val,
+								uri: `at://${author.did}/app.bsky.feed.post/fake`,
+							}),
+						),
+						author: this.profileView(scenario.quoteAuthor, {
+							account: scenario.labels.quotedAccount,
+						}),
+					})
+				: undefined,
+		});
+	}
+
+	profileScenario(scenario: ModerationTestSuiteScenario) {
+		if (scenario.subject !== 'profile') {
+			throw new Error('Scenario subject must be "profile"');
+		}
+		return this.profileView(scenario.author, scenario.labels);
+	}
+
+	profileView(name: string, scenarioLabels: ModerationTestSuiteScenario['labels']) {
+		const def = this.users[name];
+
+		const labels: ComAtprotoLabelDefs.Label[] = [];
+		if (scenarioLabels.account) {
+			for (const l of scenarioLabels.account) {
+				labels.push(m.label({ val: l, uri: `did:web:${name}` }));
+			}
+		}
+		if (scenarioLabels.profile) {
+			for (const l of scenarioLabels.profile) {
+				labels.push(
+					m.label({
+						val: l,
+						uri: `at://did:web:${name}/app.bsky.actor.profile/self`,
+					}),
+				);
+			}
+		}
+
+		return m.profileView({
+			handle: `${name}.test`,
+			labels,
+			viewer: m.actorViewerState({
+				muted: def.muted || def.mutedByList,
+				mutedByList: def.mutedByList ? m.listViewBasic({ name: 'Fake List' }) : undefined,
+				blockedBy: def.blockedBy,
+				blocking:
+					def.blocking || def.blockingByList ? 'at://did:web:self.test/app.bsky.graph.block/fake' : undefined,
+				blockingByList: def.blockingByList ? m.listViewBasic({ name: 'Fake List' }) : undefined,
+			}),
+		});
+	}
+
+	moderationOptions(scenario: ModerationTestSuiteScenario): ModerationOptions {
+		return {
+			viewerDid: this.configurations[scenario.cfg].authed === false ? undefined : 'did:web:self.test',
+			prefs: {
+				adultContentEnabled: Boolean(this.configurations[scenario.cfg]?.adultContentEnabled),
+				globalLabelPrefs: this.configurations[scenario.cfg].settings || {},
+				prefsByLabelers: {
+					'did:plc:fake-labeler': {
+						labelPrefs: {},
+					},
+				},
+				hiddenPosts: [],
+				keywordFilters: [],
+				temporaryMutes: [],
+			},
+		};
+	}
+}

package/lib/behaviors.ts

@@ -1,36 +1,39 @@
-export enum LabelTarget {
+export const LabelTarget = {
 	/** label is intended for account's content */
-	Content = 'content',
+	Content: 'content',
 	/** label is intended for account's profile */
-	Profile = 'profile',
+	Profile: 'profile',
 	/** label is intended for account's content and profile */
-	Account = 'account',
-}
+	Account: 'account',
+} as const;
+export type LabelTarget = (typeof LabelTarget)[keyof typeof LabelTarget];
 
-export enum DisplayContext {
+export const DisplayContext = {
 	/** content in expanded view */
-	ContentView = 'contentView',
+	ContentView: 'contentView',
 	/** images or video contained in content */
-	ContentMedia = 'contentMedia',
+	ContentMedia: 'contentMedia',
 	/** content in a list/feed */
-	ContentList = 'contentList',
+	ContentList: 'contentList',
 
 	/** profile in expanded view */
-	ProfileView = 'profileView',
+	ProfileView: 'profileView',
 	/** profile's avatar or banner */
-	ProfileMedia = 'profileMedia',
+	ProfileMedia: 'profileMedia',
 	/** profile in a list */
-	ProfileList = 'profileList',
-}
+	ProfileList: 'profileList',
+} as const;
+export type DisplayContext = (typeof DisplayContext)[keyof typeof DisplayContext];
 
-export enum ModerationAction {
+export const ModerationAction = {
 	/** should cause blurring */
-	Blur = 'blur',
+	Blur: 'blur',
 	/** should cause an alert */
-	Alert = 'alert',
+	Alert: 'alert',
 	/** should cause a notice */
-	Inform = 'inform',
-}
+	Inform: 'inform',
+} as const;
+export type ModerationAction = (typeof ModerationAction)[keyof typeof ModerationAction];
 
 export type BehaviorMapping = { [C in DisplayContext]?: ModerationAction };
 export type LabelBehaviorMatrix = { [T in LabelTarget]: BehaviorMapping };

package/lib/decision.ts

@@ -1,43 +1,43 @@
 import type { AppBskyGraphDefs } from '@atcute/bluesky';
 import type { Did } from '@atcute/lexicons';
 
-import { DisplayContext, ModerationAction, type BehaviorMapping, type LabelTarget } from './behaviors.js';
-import type { Label, LabelerPreference, ModerationOptions } from './types.js';
-
-import type { KeywordFilter } from './keyword-filter.js';
+import { DisplayContext, ModerationAction, type BehaviorMapping, type LabelTarget } from './behaviors.ts';
+import type { KeywordFilter } from './keyword-filter.ts';
 import {
 	BUILTIN_LABELS,
 	isCustomLabelValue,
 	LabelFlags,
 	LabelPreference,
 	type InterpretedLabelDefinition,
-} from './label.js';
+} from './label.ts';
+import type { Label, LabelerPreference, ModerationOptions } from './types.ts';
 
-const enum ModerationSeverity {
-	High = 1,
-	Medium = 2,
-	Low = 3,
-}
+const ModerationSeverity = {
+	High: 1,
+	Medium: 2,
+	Low: 3,
+} as const;
 
-export enum ModerationCauseType {
+export const ModerationCauseType = {
 	/** caused by a label */
-	Label = 1,
+	Label: 1,
 	/** caused by viewer blocking the subject */
-	Blocking = 2,
+	Blocking: 2,
 	/** caused by subject blocking the viewer */
-	BlockedBy = 3,
+	BlockedBy: 3,
 	/** caused by viewer having a (permanent) mute on subject */
-	MutedPermanent = 4,
+	MutedPermanent: 4,
 	/** caused by a temporary mute */
-	MutedTemporary = 5,
+	MutedTemporary: 5,
 	/** caused by a keyword mute */
-	MutedKeyword = 6,
+	MutedKeyword: 6,
 	/** caused by a hidden post */
-	Hidden = 7,
-}
+	Hidden: 7,
+} as const;
+export type ModerationCauseType = (typeof ModerationCauseType)[keyof typeof ModerationCauseType];
 
 export interface BlockingModerationCause {
-	type: ModerationCauseType.Blocking;
+	type: typeof ModerationCauseType.Blocking;
 	priority: 3;
 	source: AppBskyGraphDefs.ListViewBasic | null;
 
@@ -45,21 +45,21 @@ export interface BlockingModerationCause {
 }
 
 export interface BlockedByModerationCause {
-	type: ModerationCauseType.BlockedBy;
+	type: typeof ModerationCauseType.BlockedBy;
 	priority: 4;
 
 	downgraded: boolean;
 }
 
 export interface HiddenModerationCause {
-	type: ModerationCauseType.Hidden;
+	type: typeof ModerationCauseType.Hidden;
 	priority: 6;
 
 	downgraded: boolean;
 }
 
 export interface LabelModerationCause {
-	type: ModerationCauseType.Label;
+	type: typeof ModerationCauseType.Label;
 	priority: 1 | 2 | 5 | 7 | 8;
 	source: Did | null;
 
@@ -75,7 +75,7 @@ export interface LabelModerationCause {
 }
 
 export interface MutedPermanentModerationCause {
-	type: ModerationCauseType.MutedPermanent;
+	type: typeof ModerationCauseType.MutedPermanent;
 	priority: 6;
 	source: AppBskyGraphDefs.ListViewBasic | null;
 
@@ -83,14 +83,14 @@ export interface MutedPermanentModerationCause {
 }
 
 export interface MutedTemporaryModerationCause {
-	type: ModerationCauseType.MutedTemporary;
+	type: typeof ModerationCauseType.MutedTemporary;
 	priority: 6;
 
 	downgraded: boolean;
 }
 
 export interface MutedKeywordModerationCause {
-	type: ModerationCauseType.MutedKeyword;
+	type: typeof ModerationCauseType.MutedKeyword;
 	priority: 6;
 	source: KeywordFilter;
 

package/lib/index.ts

@@ -4,7 +4,7 @@ export {
 	ModerationAction,
 	type BehaviorMapping,
 	type LabelBehaviorMatrix,
-} from './behaviors.js';
+} from './behaviors.ts';
 export {
 	ModerationCauseType,
 	type BlockedByModerationCause,
@@ -16,7 +16,7 @@ export {
 	type MutedKeywordModerationCause,
 	type MutedPermanentModerationCause,
 	type MutedTemporaryModerationCause,
-} from './decision.js';
+} from './decision.ts';
 
 export {
 	createKeywordPattern,
@@ -25,7 +25,7 @@ export {
 	KeywordFilterFlags,
 	type KeywordFilter,
 	type KeywordMatch,
-} from './keyword-filter.js';
+} from './keyword-filter.ts';
 export {
 	BlurLevel,
 	interpretLabelerDefinition,
@@ -38,7 +38,7 @@ export {
 	type InterpretedLabelDefinition,
 	type InterpretedLabelMapping,
 	type LabelLocale,
-} from './label.js';
+} from './label.ts';
 
 export {
 	type FeedGeneratorSubject,
@@ -50,12 +50,12 @@ export {
 	type NotificationSubject,
 	type PostSubject,
 	type ProfileSubject,
-} from './types.js';
+} from './types.ts';
 
-export { getDisplayRestrictions, type DisplayRestrictions } from './ui.js';
+export { getDisplayRestrictions, type DisplayRestrictions } from './ui.ts';
 
-export { moderateFeedGenerator } from './subjects/feed-generator.js';
-export { moderateList } from './subjects/list.js';
-export { moderateNotification } from './subjects/notification.js';
-export { moderatePost } from './subjects/post.js';
-export { moderateProfile } from './subjects/profile.js';
+export { moderateFeedGenerator } from './subjects/feed-generator.ts';
+export { moderateList } from './subjects/list.ts';
+export { moderateNotification } from './subjects/notification.ts';
+export { moderatePost } from './subjects/post.ts';
+export { moderateProfile } from './subjects/profile.ts';

package/lib/internal/keyword-filter.ts

@@ -1,6 +1,6 @@
 import type { AppBskyActorDefs } from '@atcute/bluesky';
 
-import { KeywordFilterFlags, type KeywordFilter } from '../keyword-filter.js';
+import { KeywordFilterFlags, type KeywordFilter } from '../keyword-filter.ts';
 
 const EMPTY_ARRAY: never[] = [];
 

package/lib/keyword-filter.ts

@@ -28,7 +28,9 @@ export const createKeywordPattern = (matchers: KeywordMatch | KeywordMatch[]): R
 			continue;
 		}
 
-		re && (re += '|');
+		if (re) {
+			re += '|';
+		}
 
 		if (whole && WORD_CHAR_RE.test(value.at(0)!)) {
 			re += '\\b';
@@ -49,14 +51,15 @@ const escape = (str: string) => {
 	return str.replace(ESCAPE_RE, '\\$&');
 };
 
-export enum KeywordFilterFlags {
+export const KeywordFilterFlags = {
 	/** filter applies to content */
-	ApplyContent = 1 << 0,
+	ApplyContent: 1 << 0,
 	/** filter applies to tags */
-	ApplyTopic = 1 << 1,
+	ApplyTopic: 1 << 1,
 	/** filter shouldn't apply to following users */
-	NoFollowing = 1 << 2,
-}
+	NoFollowing: 1 << 2,
+} as const;
+export type KeywordFilterFlags = (typeof KeywordFilterFlags)[keyof typeof KeywordFilterFlags];
 
 export interface KeywordFilter {
 	/** unique identifier for this filter */

package/lib/label.ts

@@ -2,53 +2,57 @@ import type { ComAtprotoLabelDefs } from '@atcute/atproto';
 import type { AppBskyLabelerDefs } from '@atcute/bluesky';
 import type { Did } from '@atcute/lexicons';
 
-import { DisplayContext, LabelTarget, ModerationAction, type LabelBehaviorMatrix } from './behaviors.js';
+import { DisplayContext, LabelTarget, ModerationAction, type LabelBehaviorMatrix } from './behaviors.ts';
 
-export enum LabelPreference {
+export const LabelPreference = {
 	/** ignore this label */
-	Ignore = 'ignore',
+	Ignore: 'ignore',
 	/** warn when viewing content or profile with this label */
-	Warn = 'warn',
+	Warn: 'warn',
 	/** hide content or profile containing this label */
-	Hide = 'hide',
-}
+	Hide: 'hide',
+} as const;
+export type LabelPreference = (typeof LabelPreference)[keyof typeof LabelPreference];
 
-export enum LabelFlags {
+export const LabelFlags = {
 	/** no flags */
-	None = 0,
+	None: 0,
 
 	/** unblurring shouldn't be allowed */
-	NoOverride = 1 << 0,
+	NoOverride: 1 << 0,
 	/** label can't be configured */
-	NoConfigurable = 1 << 1,
+	NoConfigurable: 1 << 1,
 	/** label can't be applied as a self-label */
-	NoSelf = 1 << 2,
+	NoSelf: 1 << 2,
 	/** label is adult-only */
-	AdultOnly = 1 << 3,
+	AdultOnly: 1 << 3,
 	/** label can't be applied if authenticated */
-	UnauthenticatedOnly = 1 << 4,
-}
+	UnauthenticatedOnly: 1 << 4,
+} as const;
+export type LabelFlags = (typeof LabelFlags)[keyof typeof LabelFlags];
 
-export enum BlurLevel {
+export const BlurLevel = {
 	/** don't blur any parts of the content */
-	None = 'none',
+	None: 'none',
 	/** only blur the media present in the content */
-	Media = 'media',
+	Media: 'media',
 	/** blur the entire content */
-	Content = 'content',
+	Content: 'content',
 
 	/** special blur value, guaranteed blurring of profile and content */
-	Forced = 'forced',
-}
+	Forced: 'forced',
+} as const;
+export type BlurLevel = (typeof BlurLevel)[keyof typeof BlurLevel];
 
-export enum SeverityLevel {
+export const SeverityLevel = {
 	/** don't inform the user */
-	None = 'none',
+	None: 'none',
 	/** lightly inform the user about this label's presence */
-	Inform = 'inform',
+	Inform: 'inform',
 	/** alert the user about this label's presence */
-	Alert = 'alert',
-}
+	Alert: 'alert',
+} as const;
+export type SeverityLevel = (typeof SeverityLevel)[keyof typeof SeverityLevel];
 
 export interface LabelLocale {
 	/** language code */
@@ -253,9 +257,9 @@ export const isCustomLabelValue = (value: string): boolean => {
 export const interpretLabelValueDefinition = (
 	def: ComAtprotoLabelDefs.LabelValueDefinition,
 ): InterpretedLabelDefinition => {
-	let defaultPref = LabelPreference.Warn;
-	let blur = BlurLevel.None;
-	let severity = SeverityLevel.None;
+	let defaultPref: LabelPreference = LabelPreference.Warn;
+	let blur: BlurLevel = BlurLevel.None;
+	let severity: SeverityLevel = SeverityLevel.None;
 	let flags = LabelFlags.NoSelf;
 
 	switch (def.blurs) {

package/lib/subjects/feed-generator.ts

@@ -1,13 +1,13 @@
-import { LabelTarget } from '../behaviors.js';
+import { LabelTarget } from '../behaviors.ts';
 import {
 	considerLabels,
 	createModerationDecision,
 	mergeModerationDecisions,
 	type ModerationDecision,
-} from '../decision.js';
-import type { FeedGeneratorSubject, ModerationOptions } from '../types.js';
+} from '../decision.ts';
+import type { FeedGeneratorSubject, ModerationOptions } from '../types.ts';
 
-import { moderateProfile } from './profile.js';
+import { moderateProfile } from './profile.ts';
 
 export const moderateFeedGenerator = (
 	subject: FeedGeneratorSubject,

package/lib/subjects/list.ts

@@ -1,15 +1,15 @@
 import { parseCanonicalResourceUri } from '@atcute/lexicons';
 
-import { LabelTarget } from '../behaviors.js';
+import { LabelTarget } from '../behaviors.ts';
 import {
 	considerLabels,
 	createModerationDecision,
 	mergeModerationDecisions,
 	type ModerationDecision,
-} from '../decision.js';
-import type { ListSubject, ModerationOptions } from '../types.js';
+} from '../decision.ts';
+import type { ListSubject, ModerationOptions } from '../types.ts';
 
-import { moderateProfile } from './profile.js';
+import { moderateProfile } from './profile.ts';
 
 export const moderateList = (subject: ListSubject, opts: ModerationOptions): ModerationDecision => {
 	if ('creator' in subject) {

package/lib/subjects/notification.ts

@@ -1,13 +1,13 @@
-import { LabelTarget } from '../behaviors.js';
+import { LabelTarget } from '../behaviors.ts';
 import {
 	considerLabels,
 	createModerationDecision,
 	mergeModerationDecisions,
 	type ModerationDecision,
-} from '../decision.js';
-import type { ModerationOptions, NotificationSubject } from '../types.js';
+} from '../decision.ts';
+import type { ModerationOptions, NotificationSubject } from '../types.ts';
 
-import { moderateProfile } from './profile.js';
+import { moderateProfile } from './profile.ts';
 
 export const moderateNotification = (
 	subject: NotificationSubject,