@overlaysymphony/twitch 0.2.3 → 0.3.1

package/package.json

@@ -1,8 +1,12 @@
 {
   "name": "@overlaysymphony/twitch",
-  "version": "0.2.3",
+  "version": "0.3.1",
   "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",

package/src/authentication/authentication.ts

@@ -1,4 +1,4 @@
-import { type TwitchUser, getUsers } from "../helix/users/index.ts"
+import { type TwitchUser, getUser } from "../helix/users/index.ts"
 
 export interface Authentication {
   tokenType: "bearer"
@@ -61,7 +61,10 @@ export async function getAuthentication(
     return undefined
   }
 
-  const [user] = await getUsers(authentication as Authentication)
+  const user = await getUser(authentication as Authentication)
+  if (!user) {
+    return undefined
+  }
 
   return {
     ...authentication,

package/src/chat/chat.ts

@@ -1,161 +1,83 @@
-import createDefer from "@overlaysymphony/core/libs/defer"
-import createPubSub from "@overlaysymphony/core/libs/pubsub"
-
 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"]
+}
 
-import {
-  type TwitchChatEvent,
-  type TwitchChatEventType,
-} from "./interfaces/index.ts"
-import parseCommand from "./parser.ts"
-
-type ChatListener = (callback: (event: TwitchChatEvent) => void) => () => void
-
-type ChatSubscriber = <
-  EventType extends TwitchChatEventType,
-  Event extends TwitchChatEvent<EventType>,
->(
-  types: EventType[],
-  callback: (event: Event) => void,
-) => () => void
-
-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,
+) => () => void
 
 export interface TwitchChat {
-  listen: ChatListener
-  subscribe: ChatSubscriber
   send: ChatSender
+  announce: ChatAnnouncer
   onMessage: ChatMessageSubscriber
   onCommand: ChatCommandSubscriber
 }
 
 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
-      }
+  const onCommand: ChatCommandSubscriber = (name, callback) => {
+    const regex = /^\s*!([a-z0-9]+)(?:\s+(.+))?$/i
 
-      if (command.type === "PING") {
-        socket.send(`PONG :${command.message}`)
-        continue
-      }
+    return onMessage((payload) => {
+      const [, command, text] =
+        payload.message.text.match(regex) ?? ([] as Array<string | undefined>)
 
-      if (command.type === "CAP") {
-        socket.send(`PASS oauth:${authentication.accessToken}`)
-        socket.send(`NICK ${authentication.user.login}`)
-        continue
+      if (command !== name) {
+        return
       }
 
-      if (command.type === "RECONNECT") {
-        console.warn("The server is about to terminate for maintenance.")
-        continue
-      }
-
-      if (command.type === "GLOBALUSERSTATE") {
-        socket.send(`JOIN #${channel}`)
-        continue
-      }
+      const parameters = text?.split(" ")
 
-      if (command.type === "ROOMSTATE") {
-        resolve()
-        continue
-      }
-
-      pubsub.dispatch(command)
-    }
-  })
-
-  return promise.then(() => {
-    const listen: ChatListener = (callback) => {
-      return pubsub.subscribe((event) => {
-        callback(event)
+      callback({
+        ...payload,
+        message: {
+          command: "",
+          parameters,
+          ...payload.message,
+        },
       })
-    }
-
-    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 send: ChatSender = (message) => {
-      socket.send(`PRIVMSG #${authentication.user.login} :${message}`)
-    }
-
-    const onMessage: ChatMessageSubscriber = (callback) => {
-      return pubsub.subscribe((event) => {
-        if (event.type === "PRIVMSG") {
-          callback(event)
-        }
-      })
-    }
-
-    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.")
-      }
-
-      return pubsub.subscribe((event) => {
-        if (event.type === "PRIVMSG-COMMAND") {
-          if (typeof name === "undefined" || event.command === name) {
-            callback(event)
-          }
-        }
-      })
-    }
-
-    return {
-      listen,
-      subscribe,
-      send,
-      onMessage,
-      onCommand,
-    }
-  })
+    })
+  }
+
+  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
-
-  if (typeof broadcaster === "undefined") return null
+export function isBroadcaster(event: ApplicableChatEvent): boolean {
+  const broadcaster = !!event.badges.find((badge) => {
+    return badge.set_id === "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,8 +1,5 @@
-export type {
-  TwitchChatEventType,
-  TwitchChatEvent,
-} from "./interfaces/index.ts"
-
 export { default } from "./chat.ts"
 export * from "./chat.ts"
+
+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-helpers.ts

@@ -1,3 +1,9 @@
+export interface EventConfigs {}
+
+export type EventType = keyof EventConfigs
+export type EventPayload<Type extends EventType = EventType> =
+  EventConfigs[Type]["Payload"]
+
 export type EventConfig<
   Config extends {
     Type: string
@@ -23,12 +29,6 @@ export type EventConfig<
   }
 }
 
-export interface EventConfigs {}
-
-export type EventType = keyof EventConfigs
-export type EventPayload<Type extends EventType = EventType> =
-  EventConfigs[Type]["Payload"]
-
 const events: {
   [Type in EventType]?: {
     scopes: string[]

package/src/helix/channel-points/custom-rewards.ts

@@ -2,51 +2,83 @@ import { type Authentication } from "../../authentication/index.ts"
 import { helix } from "../helix.ts"
 
 interface CustomReward {
-  broadcaster_id: string
-  broadcaster_login: string
-  broadcaster_name: string
-  id: string
-  title: string
-  prompt: string
-  cost: number
+  broadcaster_id: string /* The ID that uniquely identifies the broadcaster. */
+  broadcaster_login: string /* The broadcaster’s login name. */
+  broadcaster_name: string /* The broadcaster’s display name. */
+  id: string /* The ID that uniquely identifies this custom reward. */
+  title: string /* The title of the reward. */
+  prompt: string /* The prompt shown to the viewer when they redeem the reward if user input is required (see the is_user_input_required field). */
+  cost: number /* The cost of the reward in Channel Points. */
+  /** A set of custom images for the reward. This field is null if the broadcaster didn’t upload images. */
   image: {
-    url_1x: string
-    url_2x: string
-    url_4x: string
+    url_1x: string /* The URL to a small version of the image. */
+    url_2x: string /* The URL to a medium version of the image. */
+    url_4x: string /* The URL to a large version of the image. */
   }
+  /** A set of default images for the reward. */
   default_image: {
-    url_1x: string
-    url_2x: string
-    url_4x: string
+    url_1x: string /* The URL to a small version of the image. */
+    url_2x: string /* The URL to a medium version of the image. */
+    url_4x: string /* The URL to a large version of the image. */
   }
-  background_color: string
-  is_enabled: boolean
-  is_user_input_required: boolean
+  background_color: string /* The background color to use for the reward. The color is in Hex format (for example, #00E5CB). */
+  is_enabled: boolean /* A Boolean value that determines whether the reward is enabled. Is true if enabled; otherwise, false. Disabled rewards aren’t shown to the user. */
+  is_user_input_required: boolean /* A Boolean value that determines whether the user must enter information when redeeming the reward. Is true if the user is prompted. */
+  /** The settings used to determine whether to apply a maximum to the number of redemptions allowed per live stream. */
   max_per_stream_setting: {
-    is_enabled: boolean
-    max_per_stream: number
+    is_enabled: boolean /* A Boolean value that determines whether the reward applies a limit on the number of redemptions allowed per live stream. Is true if the reward applies a limit. */
+    max_per_stream: number /* The maximum number of redemptions allowed per live stream. */
   }
+  /** The settings used to determine whether to apply a maximum to the number of redemptions allowed per user per live stream. */
   max_per_user_per_stream_setting: {
-    is_enabled: boolean
-    max_per_user_per_stream: number
+    is_enabled: boolean /* A Boolean value that determines whether the reward applies a limit on the number of redemptions allowed per user per live stream. Is true if the reward applies a limit. */
+    max_per_user_per_stream: number /* The maximum number of redemptions allowed per user per live stream. */
   }
+  /** The settings used to determine whether to apply a cooldown period between redemptions and the length of the cooldown. */
   global_cooldown_setting: {
-    is_enabled: boolean
-    global_cooldown_seconds: number
+    is_enabled: boolean /* A Boolean value that determines whether to apply a cooldown period. Is true if a cooldown period is enabled. */
+    global_cooldown_seconds: number /* The cooldown period, in seconds. */
   }
-  is_paused: boolean
-  is_in_stock: boolean
-  should_redemptions_skip_request_queue: boolean
-  redemptions_redeemed_current_stream: number
-  cooldown_expires_at: string
+  is_paused: boolean /* A Boolean value that determines whether the reward is currently paused. Is true if the reward is paused. Viewers can’t redeem paused rewards. */
+  is_in_stock: boolean /* A Boolean value that determines whether the reward is currently in stock. Is true if the reward is in stock. Viewers can’t redeem out of stock rewards. */
+  should_redemptions_skip_request_queue: boolean /* A Boolean value that determines whether redemptions should be set to FULFILLED status immediately when a reward is redeemed. If false, status is set to UNFULFILLED and follows the normal request queue process. */
+  redemptions_redeemed_current_stream: number /* The number of redemptions redeemed during the current live stream. The number counts against the max_per_stream_setting limit. This field is null if the broadcaster’s stream isn’t live or max_per_stream_setting isn’t enabled. */
+  cooldown_expires_at: string /* The timestamp of when the cooldown period expires. Is null if the reward isn’t in a cooldown state. See the global_cooldown_setting field. */
+}
+
+interface CustomRewardResponse {
+  data: CustomReward[]
+}
+
+interface Redemption {
+  broadcaster_id: string /** The ID that uniquely identifies the broadcaster. */
+  broadcaster_login: string /** The broadcaster’s login name. */
+  broadcaster_name: string /** The broadcaster’s display name. */
+  id: string /** The ID that uniquely identifies this redemption. */
+  user_login: string /** The user’s login name. */
+  user_id: string /** The ID that uniquely identifies the user that redeemed the reward. */
+  user_name: string /** The user’s display name. */
+  user_input: string /** The text the user entered at the prompt when they redeemed the reward; otherwise, an empty string if user input was not required. */
+  status: string /** The state of the redemption. Possible values are:\n  - CANCELED\n  - FULFILLED\n  - UNFULFILLED */
+  redeemed_at: string /** The date and time of when the reward was redeemed, in RFC3339 format. */
+  /** The reward that the user redeemed. */
+  reward: {
+    id: string /** The ID that uniquely identifies the redeemed reward. */
+    title: string /** The reward’s title. */
+    prompt: string /** The prompt displayed to the viewer if user input is required. */
+    cost: number /** The reward’s cost, in Channel Points. */
+  }
+}
+
+interface RedemptionResponse {
+  data: Redemption[]
 }
 
 export async function getCustomRewards(
   authentication: Authentication,
 ): Promise<CustomReward[]> {
-  const subscriptions = await helix<
-    CustomReward,
-    never,
+  const { data: subscriptions } = await helix<
+    CustomRewardResponse,
     {
       broadcaster_id: string
     }
@@ -60,3 +92,58 @@ export async function getCustomRewards(
 
   return subscriptions
 }
+
+export async function getRedemptions(
+  authentication: Authentication,
+  reward_id: string,
+  id: string,
+): Promise<Redemption[]> {
+  const { data: redemptions } = await helix<
+    RedemptionResponse,
+    {
+      broadcaster_id: string
+      reward_id: string
+      id?: string
+      status?: "CANCELED" | "FULFILLED" | "UNFULFILLED"
+    }
+  >(authentication, {
+    method: "GET",
+    path: "/channel_points/custom_rewards",
+    params: {
+      broadcaster_id: authentication.user.id,
+      reward_id,
+      id,
+      status: id ? undefined : "UNFULFILLED",
+    },
+  })
+
+  return redemptions
+}
+
+export async function updateRedemption(
+  authentication: Authentication,
+  reward_id: string,
+  id: string,
+  status: "CANCELED" | "FULFILLED",
+): Promise<Redemption[]> {
+  const { data: redemptions } = await helix<
+    RedemptionResponse,
+    {
+      broadcaster_id: string
+      reward_id: string
+      id: string
+      status: "CANCELED" | "FULFILLED"
+    }
+  >(authentication, {
+    method: "POST",
+    path: "/channel_points/custom_rewards",
+    params: {
+      broadcaster_id: authentication.user.id,
+      reward_id,
+      id,
+      status,
+    },
+  })
+
+  return redemptions
+}