@atproto/api 0.15.13 → 0.15.15

package/src/client/types/app/bsky/notification/defs.ts

@@ -27,3 +27,79 @@ export function isRecordDeleted<V>(v: V) {
 export function validateRecordDeleted<V>(v: V) {
   return validate<RecordDeleted & V>(v, id, hashRecordDeleted)
 }
+
+export interface ChatPreference {
+  $type?: 'app.bsky.notification.defs#chatPreference'
+  filter: 'all' | 'accepted' | (string & {})
+  push: boolean
+}
+
+const hashChatPreference = 'chatPreference'
+
+export function isChatPreference<V>(v: V) {
+  return is$typed(v, id, hashChatPreference)
+}
+
+export function validateChatPreference<V>(v: V) {
+  return validate<ChatPreference & V>(v, id, hashChatPreference)
+}
+
+export interface FilterablePreference {
+  $type?: 'app.bsky.notification.defs#filterablePreference'
+  filter: 'all' | 'follows' | (string & {})
+  list: boolean
+  push: boolean
+}
+
+const hashFilterablePreference = 'filterablePreference'
+
+export function isFilterablePreference<V>(v: V) {
+  return is$typed(v, id, hashFilterablePreference)
+}
+
+export function validateFilterablePreference<V>(v: V) {
+  return validate<FilterablePreference & V>(v, id, hashFilterablePreference)
+}
+
+export interface Preference {
+  $type?: 'app.bsky.notification.defs#preference'
+  list: boolean
+  push: boolean
+}
+
+const hashPreference = 'preference'
+
+export function isPreference<V>(v: V) {
+  return is$typed(v, id, hashPreference)
+}
+
+export function validatePreference<V>(v: V) {
+  return validate<Preference & V>(v, id, hashPreference)
+}
+
+export interface Preferences {
+  $type?: 'app.bsky.notification.defs#preferences'
+  chat: ChatPreference
+  follow: FilterablePreference
+  like: FilterablePreference
+  likeViaRepost: FilterablePreference
+  mention: FilterablePreference
+  quote: FilterablePreference
+  reply: FilterablePreference
+  repost: FilterablePreference
+  repostViaRepost: FilterablePreference
+  starterpackJoined: Preference
+  subscribedPost: Preference
+  unverified: Preference
+  verified: Preference
+}
+
+const hashPreferences = 'preferences'
+
+export function isPreferences<V>(v: V) {
+  return is$typed(v, id, hashPreferences)
+}
+
+export function validatePreferences<V>(v: V) {
+  return validate<Preferences & V>(v, id, hashPreferences)
+}

package/src/client/types/app/bsky/notification/getPreferences.ts

@@ -0,0 +1,40 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { HeadersMap, XRPCError } from '@atproto/xrpc'
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+import type * as AppBskyNotificationDefs from './defs.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'app.bsky.notification.getPreferences'
+
+export interface QueryParams {}
+
+export type InputSchema = undefined
+
+export interface OutputSchema {
+  preferences: AppBskyNotificationDefs.Preferences
+}
+
+export interface CallOptions {
+  signal?: AbortSignal
+  headers?: HeadersMap
+}
+
+export interface Response {
+  success: boolean
+  headers: HeadersMap
+  data: OutputSchema
+}
+
+export function toKnownErr(e: any) {
+  return e
+}

package/src/client/types/app/bsky/notification/putPreferencesV2.ts

@@ -0,0 +1,56 @@
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { HeadersMap, XRPCError } from '@atproto/xrpc'
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+import type * as AppBskyNotificationDefs from './defs.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'app.bsky.notification.putPreferencesV2'
+
+export interface QueryParams {}
+
+export interface InputSchema {
+  chat?: AppBskyNotificationDefs.ChatPreference
+  follow?: AppBskyNotificationDefs.FilterablePreference
+  like?: AppBskyNotificationDefs.FilterablePreference
+  likeViaRepost?: AppBskyNotificationDefs.FilterablePreference
+  mention?: AppBskyNotificationDefs.FilterablePreference
+  quote?: AppBskyNotificationDefs.FilterablePreference
+  reply?: AppBskyNotificationDefs.FilterablePreference
+  repost?: AppBskyNotificationDefs.FilterablePreference
+  repostViaRepost?: AppBskyNotificationDefs.FilterablePreference
+  starterpackJoined?: AppBskyNotificationDefs.Preference
+  subscribedPost?: AppBskyNotificationDefs.Preference
+  unverified?: AppBskyNotificationDefs.Preference
+  verified?: AppBskyNotificationDefs.Preference
+}
+
+export interface OutputSchema {
+  preferences: AppBskyNotificationDefs.Preferences
+}
+
+export interface CallOptions {
+  signal?: AbortSignal
+  headers?: HeadersMap
+  qp?: QueryParams
+  encoding?: 'application/json'
+}
+
+export interface Response {
+  success: boolean
+  headers: HeadersMap
+  data: OutputSchema
+}
+
+export function toKnownErr(e: any) {
+  return e
+}

package/src/moderation/decision.ts

@@ -1,5 +1,6 @@
 import { AppBskyGraphDefs } from '../client/index'
 import { LABELS } from './const/labels'
+import { MuteWordMatch } from './mutewords'
 import {
   BLOCK_BEHAVIOR,
   CUSTOM_LABEL_VALUE_RE,
@@ -195,12 +196,13 @@ export class ModerationDecision {
     }
   }
 
-  addMutedWord(mutedWord: boolean) {
-    if (mutedWord) {
+  addMutedWord(matches: MuteWordMatch[] | undefined) {
+    if (matches?.length) {
       this.causes.push({
         type: 'mute-word',
         source: { type: 'user' },
         priority: 6,
+        matches,
       })
     }
   }

package/src/moderation/index.ts

@@ -16,7 +16,7 @@ import {
 
 export { ModerationUI } from './ui'
 export { ModerationDecision } from './decision'
-export { hasMutedWord } from './mutewords'
+export { hasMutedWord, matchMuteWords } from './mutewords'
 export {
   interpretLabelValueDefinition,
   interpretLabelValueDefinitions,

package/src/moderation/mutewords.ts

@@ -21,21 +21,38 @@ const LANGUAGE_EXCEPTIONS = [
   'vi', // Vietnamese
 ]
 
-export function hasMutedWord({
-  mutedWords,
-  text,
-  facets,
-  outlineTags,
-  languages,
-  actor,
-}: {
+export type MuteWordMatch = {
+  /**
+   * The `AppBskyActorDefs.MutedWord` that matched.
+   */
+  word: AppBskyActorDefs.MutedWord
+  /**
+   * The string that matched the muted word.
+   */
+  predicate: string
+}
+
+export type Params = {
   mutedWords: AppBskyActorDefs.MutedWord[]
   text: string
   facets?: AppBskyRichtextFacet.Main[]
   outlineTags?: string[]
   languages?: string[]
   actor?: AppBskyActorDefs.ProfileView | AppBskyActorDefs.ProfileViewBasic
-}) {
+}
+
+/**
+ * Checks if the given text matches any of the muted words, returning an array
+ * of matches. If no matches are found, returns `undefined`.
+ */
+export function matchMuteWords({
+  mutedWords,
+  text,
+  facets,
+  outlineTags,
+  languages,
+  actor,
+}: Params): MuteWordMatch[] | undefined {
   const exception = LANGUAGE_EXCEPTIONS.includes(languages?.[0] || '')
   const tags = ([] as string[])
     .concat(outlineTags || [])
@@ -46,38 +63,54 @@ export function hasMutedWord({
     )
     .map((t) => t.toLowerCase())
 
-  for (const mute of mutedWords) {
-    const mutedWord = mute.value.toLowerCase()
+  const matches: MuteWordMatch[] = []
+
+  outer: for (const muteWord of mutedWords) {
+    const mutedWord = muteWord.value.toLowerCase()
     const postText = text.toLowerCase()
 
     // expired, ignore
-    if (mute.expiresAt && mute.expiresAt < new Date().toISOString()) continue
+    if (muteWord.expiresAt && muteWord.expiresAt < new Date().toISOString())
+      continue
 
     if (
-      mute.actorTarget === 'exclude-following' &&
+      muteWord.actorTarget === 'exclude-following' &&
       Boolean(actor?.viewer?.following)
     )
       continue
 
     // `content` applies to tags as well
-    if (tags.includes(mutedWord)) return true
+    if (tags.includes(mutedWord)) {
+      matches.push({ word: muteWord, predicate: muteWord.value })
+      continue
+    }
     // rest of the checks are for `content` only
-    if (!mute.targets.includes('content')) continue
+    if (!muteWord.targets.includes('content')) continue
     // single character or other exception, has to use includes
-    if ((mutedWord.length === 1 || exception) && postText.includes(mutedWord))
-      return true
+    if ((mutedWord.length === 1 || exception) && postText.includes(mutedWord)) {
+      matches.push({ word: muteWord, predicate: muteWord.value })
+      continue
+    }
     // too long
     if (mutedWord.length > postText.length) continue
     // exact match
-    if (mutedWord === postText) return true
+    if (mutedWord === postText) {
+      matches.push({ word: muteWord, predicate: muteWord.value })
+      continue
+    }
     // any muted phrase with space or punctuation
-    if (/(?:\s|\p{P})+?/u.test(mutedWord) && postText.includes(mutedWord))
-      return true
+    if (/(?:\s|\p{P})+?/u.test(mutedWord) && postText.includes(mutedWord)) {
+      matches.push({ word: muteWord, predicate: muteWord.value })
+      continue
+    }
 
     // check individual character groups
     const words = postText.split(REGEX.WORD_BOUNDARY)
     for (const word of words) {
-      if (word === mutedWord) return true
+      if (word === mutedWord) {
+        matches.push({ word: muteWord, predicate: word })
+        continue outer
+      }
 
       // compare word without leading/trailing punctuation, but allow internal
       // punctuation (such as `s@ssy`)
@@ -86,23 +119,52 @@ export function hasMutedWord({
         '',
       )
 
-      if (mutedWord === wordTrimmedPunctuation) return true
+      if (mutedWord === wordTrimmedPunctuation) {
+        matches.push({ word: muteWord, predicate: word })
+        continue outer
+      }
+
       if (mutedWord.length > wordTrimmedPunctuation.length) continue
 
       if (/\p{P}+/u.test(wordTrimmedPunctuation)) {
+        /**
+         * Exit case for any punctuation within the predicate that we _do_
+         * allow e.g. `and/or` should not match `Andor`.
+         */
+        if (/[/]+/.test(wordTrimmedPunctuation)) {
+          continue outer
+        }
+
         const spacedWord = wordTrimmedPunctuation.replace(/\p{P}+/gu, ' ')
-        if (spacedWord === mutedWord) return true
+        if (spacedWord === mutedWord) {
+          matches.push({ word: muteWord, predicate: word })
+          continue outer
+        }
 
         const contiguousWord = spacedWord.replace(/\s/gu, '')
-        if (contiguousWord === mutedWord) return true
+        if (contiguousWord === mutedWord) {
+          matches.push({ word: muteWord, predicate: word })
+          continue outer
+        }
 
         const wordParts = wordTrimmedPunctuation.split(/\p{P}+/u)
         for (const wordPart of wordParts) {
-          if (wordPart === mutedWord) return true
+          if (wordPart === mutedWord) {
+            matches.push({ word: muteWord, predicate: word })
+            continue outer
+          }
         }
       }
     }
   }
 
-  return false
+  return matches.length ? matches : undefined
+}
+
+/**
+ * Checks if the given text matches any of the muted words, returning a boolean
+ * if any matches are found.
+ */
+export function hasMutedWord(params: Params) {
+  return !!matchMuteWords(params)
 }