@overlaysymphony/twitch 0.2.2 → 0.3.0

package/package.json

@@ -1,8 +1,12 @@
 {
   "name": "@overlaysymphony/twitch",
-  "version": "0.2.2",
+  "version": "0.3.0",
   "description": "Twitch module for the OverlaySymphony interactive streaming framework.",
   "homepage": "https://github.com/OverlaySymphony/overlaysymphony",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/OverlaySymphony/overlaysymphony"
+  },
   "type": "module",
   "exports": {
     "./authentication": "./src/authentication/index.ts",
@@ -14,7 +18,7 @@
     "./package.json": "./package.json"
   },
   "dependencies": {
-    "@overlaysymphony/core": "0.2.0"
+    "@overlaysymphony/core": "0.2.1"
   },
   "devDependencies": {
     "@vitest/coverage-v8": "^2.1.2",

package/src/authentication/authentication.ts

@@ -1,4 +1,4 @@
-import { type TwitchUser, getUsers } from "../helix/users/index.js"
+import { type TwitchUser, getUsers } from "../helix/users/index.ts"
 
 export interface Authentication {
   tokenType: "bearer"

package/src/authentication/index.ts

@@ -1 +1 @@
-export * from "./authentication.js"
+export * from "./authentication.ts"

package/src/chat/chat.ts

@@ -1,161 +1,96 @@
-import createDefer from "@overlaysymphony/core/libs/defer"
-import createPubSub from "@overlaysymphony/core/libs/pubsub"
-
-import { type Authentication } from "../authentication/index.js"
-
-import {
-  type TwitchChatEvent,
-  type TwitchChatEventType,
-} from "./interfaces/index.js"
-import parseCommand from "./parser.js"
-
-type ChatListener = (callback: (event: TwitchChatEvent) => void) => () => void
-
-type ChatSubscriber = <
-  EventType extends TwitchChatEventType,
-  Event extends TwitchChatEvent<EventType>,
->(
-  types: EventType[],
-  callback: (event: Event) => void,
-) => () => void
+import { type Authentication } from "../authentication/index.ts"
+import { type EventPayload } from "../eventsub/events-helpers.ts"
+import createEventSub, { type TwitchEventSub } from "../eventsub/index.ts"
+import { sendChatAnnouncement, sendChatMessage } from "../helix/chat/index.ts"
+
+type ChatMessage = EventPayload<"channel.chat.message">["event"]
+type ChatCommand = ChatMessage & {
+  message: {
+    command: string
+    parameters?: string[]
+  } & ChatMessage["message"]
+}
 
-type ChatSender = (message: string) => void
+type ChatSender = (message: string) => Promise<void>
+type ChatAnnouncer = (message: string, color?: string) => Promise<void>
 
 type ChatMessageSubscriber = (
-  callback: (event: TwitchChatEvent<"PRIVMSG">) => void,
+  callback: (event: ChatMessage) => void,
 ) => () => void
 
-interface ChatCommandSubscriber {
-  (
-    callback: (event: TwitchChatEvent<"PRIVMSG-COMMAND">) => void,
-    name?: never,
-  ): () => void
-  (
-    name: string,
-    callback: (event: TwitchChatEvent<"PRIVMSG-COMMAND">) => void,
-  ): () => void
-}
+type ChatCommandSubscriber = (
+  name: string,
+  callback: (event: ChatCommand) => void,
+  ___?: never,
+) => () => void
+// type ChatCommandSubscriber = (
+//   name: string,
+//   pattern: string,
+//   callback: (event: ChatCommand) => void,
+// ) => () => void
 
 export interface TwitchChat {
-  listen: ChatListener
-  subscribe: ChatSubscriber
   send: ChatSender
+  announce: ChatAnnouncer
   onMessage: ChatMessageSubscriber
   onCommand: ChatCommandSubscriber
 }
 
-export async function createChat(
+export default async function createChat(
   authentication: Authentication,
-  channel: string = authentication.user.login,
+  eventsub?: TwitchEventSub,
 ): Promise<TwitchChat> {
-  const { promise, resolve } = createDefer()
+  eventsub ??= await createEventSub(authentication)
 
-  const pubsub = createPubSub<TwitchChatEvent>()
-  const socket = new WebSocket("wss://irc-ws.chat.twitch.tv:443")
+  const send: ChatSender = async (message) => {
+    await sendChatMessage(authentication, message)
+  }
 
-  socket.addEventListener("open", (connection) => {
-    socket.send("CAP REQ :twitch.tv/tags twitch.tv/commands")
-  })
+  const announce: ChatAnnouncer = async (message, color) => {
+    await sendChatAnnouncement(authentication, message, color)
+  }
 
-  socket.addEventListener("message", ({ data }: { data: string }) => {
-    const messages = data.split("\r\n").filter(Boolean)
-    for (const input of messages) {
-      const command = parseCommand(input)
-      if (!command) {
-        continue
-      }
+  const onMessage: ChatMessageSubscriber = (callback) => {
+    return eventsub.on(["channel.chat.message"], (payload) => {
+      callback(payload.event)
+    })
+  }
 
-      if (
-        command.type === "001" ||
-        command.type === "JOIN" ||
-        command.type === "USERSTATE" ||
-        command.type === "HOSTTARGET" ||
-        command.type === "NOTICE"
-      ) {
-        continue
-      }
-
-      if (command.type === "PING") {
-        socket.send(`PONG :${command.message}`)
-        continue
-      }
-
-      if (command.type === "CAP") {
-        socket.send(`PASS oauth:${authentication.accessToken}`)
-        socket.send(`NICK ${authentication.user.login}`)
-        continue
-      }
-
-      if (command.type === "RECONNECT") {
-        console.warn("The server is about to terminate for maintenance.")
-        continue
-      }
+  const onCommand: ChatCommandSubscriber = (name, ...args) => {
+    const pattern = typeof args[0] === "string" ? args[0] : undefined
 
-      if (command.type === "GLOBALUSERSTATE") {
-        socket.send(`JOIN #${channel}`)
-        continue
-      }
-
-      if (command.type === "ROOMSTATE") {
-        resolve()
-        continue
-      }
-
-      pubsub.dispatch(command)
-    }
-  })
-
-  return promise.then(() => {
-    const listen: ChatListener = (callback) => {
-      return pubsub.subscribe((event) => {
-        callback(event)
-      })
-    }
-
-    const subscribe: ChatSubscriber = (types, callback) => {
-      return pubsub.subscribe((event) => {
-        // @ts-expect-error: generic events are complicated
-        if (types.includes(event.type)) {
-          // @ts-expect-error: generic events are complicated
-          callback(event)
-        }
-      })
+    const callback = typeof args[0] === "function" ? args[0] : args[1]
+    if (!callback) {
+      throw new Error("onCommand: Missing callback.")
     }
 
-    const send: ChatSender = (message) => {
-      socket.send(`PRIVMSG #${authentication.user.login} :${message}`)
-    }
+    const regex = new RegExp(`^\\s*!([a-z0-9])(?:\\s+(.+))$`, "i")
 
-    const onMessage: ChatMessageSubscriber = (callback) => {
-      return pubsub.subscribe((event) => {
-        if (event.type === "PRIVMSG") {
-          callback(event)
-        }
-      })
-    }
+    return onMessage((payload) => {
+      const [command, text] =
+        payload.message.text.match(regex) ?? ([] as Array<string | undefined>)
 
-    const onCommand: ChatCommandSubscriber = (...args) => {
-      const name = typeof args[0] === "string" ? args[0] : undefined
-      const callback = typeof args[0] === "function" ? args[0] : args[1]
-      if (!callback) {
-        throw new Error("onCommand: Missing callback.")
+      if (command !== name) {
+        return
       }
 
-      return pubsub.subscribe((event) => {
-        if (event.type === "PRIVMSG-COMMAND") {
-          if (typeof name === "undefined" || event.command === name) {
-            callback(event)
-          }
-        }
-      })
-    }
+      const parameters = pattern ? undefined : text?.split(" ")
 
-    return {
-      listen,
-      subscribe,
-      send,
-      onMessage,
-      onCommand,
-    }
-  })
+      callback({
+        ...payload,
+        message: {
+          command: "",
+          parameters,
+          ...payload.message,
+        },
+      })
+    })
+  }
+
+  return {
+    send,
+    announce,
+    onMessage,
+    onCommand,
+  }
 }

package/src/chat/helpers.ts

@@ -1,36 +1,45 @@
 interface ApplicableChatEvent {
-  tags?: {
-    mod?: boolean
-    badges?: {
-      broadcaster?: boolean
-    }
-  }
+  badges: Array<{
+    set_id: string
+    id: string
+    info: string
+  }>
 }
 
-export function isBroadcaster(event: ApplicableChatEvent): boolean | null {
-  const broadcaster = event.tags?.badges?.broadcaster
+export function isBroadcaster(event: ApplicableChatEvent): boolean {
+  const broadcaster = !!event.badges.find((badge) => {
+    return badge.set_id === "broadcaster"
+  })
 
-  if (typeof broadcaster === "undefined") return null
-
-  return !!broadcaster
+  return broadcaster
 }
 
-export function isMod(event: ApplicableChatEvent): boolean | null {
-  const broadcaster = event.tags?.badges?.broadcaster
-  const mod = event.tags?.mod
-
-  if (typeof broadcaster === "undefined" || typeof mod === "undefined")
-    return null
+export function isModerator(event: ApplicableChatEvent): boolean {
+  const broadcaster = !!event.badges.find((badge) => {
+    return badge.set_id === "broadcaster"
+  })
+  const moderator = !!event.badges.find((badge) => {
+    return badge.set_id === "moderator"
+  })
 
-  return broadcaster || mod
+  return broadcaster || moderator
 }
 
-export function isModOnly(event: ApplicableChatEvent): boolean | null {
-  const broadcaster = event.tags?.badges?.broadcaster
-  const mod = event.tags?.mod
+export function isModeratorOnly(event: ApplicableChatEvent): boolean {
+  const broadcaster = !!event.badges.find((badge) => {
+    return badge.set_id === "broadcaster"
+  })
+  const moderator = !!event.badges.find((badge) => {
+    return badge.set_id === "moderator"
+  })
+
+  return !broadcaster && moderator
+}
 
-  if (typeof broadcaster === "undefined" || typeof mod === "undefined")
-    return null
+export function isSubscriber(event: ApplicableChatEvent): false | number {
+  const subscriber = event.badges.find((badge) => {
+    return badge.set_id === "subscriber"
+  })
 
-  return mod && !broadcaster
+  return +(subscriber?.info ?? "0") || false
 }

package/src/chat/index.ts

@@ -1,7 +1,5 @@
-export type {
-  TwitchChatEventType,
-  TwitchChatEvent,
-} from "./interfaces/index.js"
+export { default } from "./chat.ts"
+export * from "./chat.ts"
 
-export * from "./chat.js"
-export * from "./helpers.js"
+export * from "./pronouns.ts"
+export * from "./helpers.ts"

package/src/chat/pronouns.ts

@@ -0,0 +1,141 @@
+type AllPronounsResponse = Array<{
+  name: string
+  display: string
+}>
+
+type UserPronounsResponse = Array<{
+  id: string
+  login: string
+  pronoun_id: string
+}>
+
+type Pronouns = {
+  subject: string
+  object: string
+  posessive: string
+}
+
+const pronouns: Record<string, Pronouns> = {
+  hehim: {
+    subject: "he",
+    object: "him",
+    posessive: "his",
+  },
+  sheher: {
+    subject: "she",
+    object: "her",
+    posessive: "her",
+  },
+  theythem: {
+    subject: "they",
+    object: "them",
+    posessive: "their",
+  },
+  shethem: {
+    subject: "she",
+    object: "they",
+    posessive: "their",
+  },
+  hethem: {
+    subject: "he",
+    object: "they",
+    posessive: "their",
+  },
+  heshe: {
+    subject: "he",
+    object: "she",
+    posessive: "their",
+  },
+  xexem: {
+    subject: "xe",
+    object: "xem",
+    posessive: "xeir",
+  },
+  faefaer: {
+    subject: "fae",
+    object: "faer",
+    posessive: "faer",
+  },
+  vever: {
+    subject: "ve",
+    object: "ver",
+    posessive: "ver",
+  },
+  aeaer: {
+    subject: "ae",
+    object: "aer",
+    posessive: "aer",
+  },
+  ziehir: {
+    subject: "zie",
+    object: "hir",
+    posessive: "hir",
+  },
+  perper: {
+    subject: "per",
+    object: "per",
+    posessive: "per",
+  },
+  eem: {
+    subject: "e",
+    object: "em",
+    posessive: "eir",
+  },
+  itits: {
+    subject: "it",
+    object: "its",
+    posessive: "its",
+  },
+}
+
+const cache: Partial<Record<string, keyof typeof pronouns>> = {}
+
+export async function getAllPronouns(): Promise<AllPronounsResponse> {
+  const response = await fetch("https://pronouns.alejo.io/api/pronouns")
+
+  if (!response.ok) {
+    throw new Error(await response.text())
+  }
+
+  const data = (await response.json()) as AllPronounsResponse
+
+  return data
+}
+
+export async function getUserPronouns(
+  login: string,
+): Promise<string | undefined> {
+  const response = await fetch(`https://pronouns.alejo.io/api/users/${login}`)
+
+  if (!response.ok) {
+    return undefined
+  }
+
+  try {
+    const data = (await response.json()) as UserPronounsResponse
+
+    return data[0].pronoun_id
+  } catch {
+    return undefined
+  }
+}
+
+export async function getPronouns(
+  login: string,
+  fallback: keyof typeof pronouns = "theythem",
+): Promise<{
+  subject: string
+  object: string
+}> {
+  if (!(login in cache)) {
+    try {
+      const id = await getUserPronouns(login)
+      cache[login] = id
+    } catch {
+      cache[login] = undefined
+    }
+  }
+
+  const id = cache[login] ?? fallback
+  return pronouns[id]
+}

package/src/eventsub/events/automod.message.hold-2.ts

@@ -0,0 +1,81 @@
+import { type EventConfig, registerEvent } from "../events-helpers.ts"
+
+declare module "../events-helpers.ts" {
+  interface EventConfigs {
+    "automod.message.hold": AutomodMessageHold
+  }
+}
+
+/** Automod Message Hold v2: When the user's message is caught by automod for review.  Only public blocked terms trigger notifications, not private ones. */
+type AutomodMessageHold = EventConfig<{
+  Type: "automod.message.hold"
+  Version: "2"
+  /** The conditions to listen for when the user's message is caught by automod for review.  Only public blocked terms trigger notifications, not private ones. */
+  Condition: {
+    /** User ID of the broadcaster (channel). */
+    broadcaster_user_id: string
+    /** User ID of the moderator. */
+    moderator_user_id: string
+  }
+  /** The event fired when the user's message is caught by automod for review.  Only public blocked terms trigger notifications, not private ones. */
+  Event: {
+    /** The ID of the broadcaster specified in the request. */
+    broadcaster_user_id: string
+    /** The login of the broadcaster specified in the request. */
+    broadcaster_user_login: string
+    /** The user name of the broadcaster specified in the request. */
+    broadcaster_user_name: string
+    /** The message sender's user ID. */
+    user_id: string
+    /** The message sender's login name. */
+    user_login: string
+    /** The message sender's display name. */
+    user_name: string
+    /** The ID of the message that was flagged by automod. */
+    message_id: string
+    /** The body of the message. */
+    message: {
+      /** The contents of the message caught by automod. */
+      text: string
+      /** Metadata surrounding the potential inappropriate fragments of the message. */
+      fragments: Array<{
+        /** Message text in a fragment. */
+        text: string
+        /** Metadata pertaining to the emote. */
+        emote?: {
+          /** An ID that uniquely identifies this emote. */
+          id: string
+          /** An ID that identifies the emote set that the emote belongs to. */
+          emote_set_id: string
+        }
+        /** Metadata pertaining to the cheermote. */
+        cheermote?: {
+          /** The name portion of the Cheermote string that you use in chat to cheer Bits. The full Cheermote string is the concatenation of {prefix} + {number of Bits}. */
+          prefix: string
+          /** The amount of Bits cheered. */
+          bits: number
+          /** The tier level of the cheermote. */
+          tier: number
+        }
+      }>
+    }
+    /** The category of the message. */
+    category: string
+    /** The level of severity. Measured between 1 to 4. */
+    level: number
+    /** The timestamp of when automod saved the message. */
+    held_at: string
+  }
+}>
+
+registerEvent("automod.message.hold", {
+  scopes: ["moderator:manage:automod"],
+  subscriber: (userId) => ({
+    type: "automod.message.hold",
+    version: "2",
+    condition: {
+      broadcaster_user_id: userId,
+      moderator_user_id: userId,
+    },
+  }),
+})

package/src/eventsub/events/automod.message.update-2.ts

@@ -0,0 +1,94 @@
+import { type EventConfig, registerEvent } from "../events-helpers.ts"
+
+declare module "../events-helpers.ts" {
+  interface EventConfigs {
+    "automod.message.update": AutomodMessageUpdate
+  }
+}
+
+/** Automod Message Update v2: When a message in the automod queue had its status changed. Only public blocked terms trigger notifications, not private ones. */
+type AutomodMessageUpdate = EventConfig<{
+  Type: "automod.message.update"
+  Version: "2"
+  /** The conditions to listen for when a message in the automod queue had its status changed. Only public blocked terms trigger notifications, not private ones. */
+  Condition: {
+    /** User ID of the broadcaster (channel). Maximum:1. */
+    broadcaster_user_id: string
+    /** User ID of the moderator. */
+    moderator_user_id: string
+  }
+  /** The event fired when a message in the automod queue had its status changed. Only public blocked terms trigger notifications, not private ones. */
+  Event: {
+    /** The ID of the broadcaster specified in the request. */
+    broadcaster_user_id: string
+    /** The login of the broadcaster specified in the request. */
+    broadcaster_user_login: string
+    /** The user name of the broadcaster specified in the request. */
+    broadcaster_user_name: string
+    /** The message sender's user ID. */
+    user_id: string
+    /** The message sender's login name. */
+    user_login: string
+    /** The message sender's display name. */
+    user_name: string
+    /** The ID of the moderator. */
+    moderator_user_id: string
+    /** TThe moderator's user name. */
+    moderator_user_name: string
+    /** The login of the moderator. */
+    moderator_user_login: string
+    /** The ID of the message that was flagged by automod. */
+    message_id: string
+    /** The body of the message. */
+    message: {
+      /** The contents of the message caught by automod. */
+      text: string
+      /** Metadata surrounding the potential inappropriate fragments of the message. */
+      fragments: Array<{
+        /** Message text in a fragment. */
+        text: string
+        /** Metadata pertaining to the emote. */
+        emote?: {
+          /** An ID that uniquely identifies this emote. */
+          id: string
+          /** An ID that identifies the emote set that the emote belongs to. */
+          emote_set_id: string
+        }
+        /** Metadata pertaining to the cheermote. */
+        cheermote?: {
+          /** The name portion of the Cheermote string that you use in chat to cheer Bits. The full Cheermote string is the concatenation of {prefix} + {number of Bits}. */
+          prefix: string
+          /** The amount of Bits cheered. */
+          bits: number
+          /** The tier level of the cheermote. */
+          tier: number
+        }
+      }>
+    }
+    /** The category of the message. */
+    category: string
+    /** The level of severity. Measured between 1 to 4. */
+    level: number
+    /**
+     * The message's status. Possible values are:
+     * - Approved
+     * - Denied
+     * - Expired
+     */
+    status: string
+    /** The timestamp of when automod saved the message. */
+    held_at: string
+  }
+}>
+
+registerEvent("automod.message.update", {
+  scopes: ["moderator:manage:automod"],
+  subscriber: (userId) => ({
+    type: "automod.message.update",
+    version: "2",
+    condition: {
+      broadcaster_user_id: userId,
+      moderator_user_id: userId,
+    },
+  }),
+})