@overlaysymphony/twitch 0.1.1 → 0.2.1

package/README.md

@@ -1,4 +1,4 @@
-# `@overlaysymphony/obs`
+# `@overlaysymphony/twitch`
 
 This module enables [Twitch](https://dev.twitch.tv/docs/) integrations for the [OverlaySymphony interactive streaming framework](https://github.com/OverlaySymphony/overlaysymphony), including authentication, chat, eventsub, helix, and several helpers.
 

package/package.json

@@ -1,40 +1,38 @@
 {
   "name": "@overlaysymphony/twitch",
-  "version": "0.1.1",
+  "version": "0.2.1",
   "description": "Twitch module for the OverlaySymphony interactive streaming framework.",
   "homepage": "https://github.com/OverlaySymphony/overlaysymphony",
   "type": "module",
   "exports": {
-    "./authentication": "./src/authentication/index.js",
-    "./chat": "./src/chat/index.js",
-    "./eventsub": "./src/eventsub/index.js",
-    "./helix/*": "./src/helix/*/index.js",
-    "./helpers/*": "./src/helpers/*/index.js",
-    "./ui/*": "./src/ui/*.js",
+    "./authentication": "./src/authentication/index.ts",
+    "./chat": "./src/chat/index.ts",
+    "./eventsub": "./src/eventsub/index.ts",
+    "./helix/*": "./src/helix/*/index.ts",
+    "./helpers/*": "./src/helpers/*/index.ts",
+    "./ui/*": "./src/ui/*.ts",
     "./package.json": "./package.json"
   },
   "dependencies": {
-    "@overlaysymphony/core": "0.1.0"
+    "@overlaysymphony/core": "0.2.0"
   },
   "devDependencies": {
     "@vitest/coverage-v8": "^2.1.2",
     "depcheck": "^1.4.7",
-    "eslint": "^8.57.0",
-    "prettier": "^3.3.3",
-    "typescript": "~5.5.0",
+    "eslint": "^9.19.0",
+    "prettier": "^3.4.2",
+    "typescript": "^5.7.2",
+    "vite": "^6.2.1",
     "vitest": "^2.1.2",
-    "@overlaysymphony/tooling": "0.0.0",
-    "@overlaysymphony/eslint-config": "0.0.0"
+    "@overlaysymphony/tooling": "0.0.0"
   },
   "scripts": {
     "lint": "pnpm run \"/^lint-.*/\"",
     "lint-typecheck": "tsc --noEmit",
-    "lint-eslint": "eslint --ext .js --ext .jsx --ext .ts --ext .tsx .",
+    "lint-eslint": "eslint .",
     "lint-prettier": "prettier --check .",
     "lint-depcheck": "depcheck .",
     "test": "vitest",
-    "dev": "echo TODO",
-    "clean": "rm -rf node_modules/.cache tsconfig.tsbuildinfo dist",
-    "build": "echo TODO"
+    "clean": "rm -rf node_modules/.cache tsconfig.tsbuildinfo"
   }
 }

package/src/authentication/authentication.ts

@@ -1,10 +1,8 @@
-import querystring from "@overlaysymphony/core/libs/querystring"
-
-import { TwitchUser, getUsers } from "../helix/users/index.js"
+import { type TwitchUser, getUsers } from "../helix/users/index.js"
 
 export interface Authentication {
-  clientId: string
   tokenType: "bearer"
+  clientId: string
   accessToken: string
   scope: string[]
   expires: Date
@@ -13,53 +11,123 @@ export interface Authentication {
 
 export type BareAuthentication = Omit<Authentication, "user">
 
-interface TAValidation {
-  client_id: string
-  login: string
-  scope: string[]
-  user_id: string
-  expires_in: number
+const localStorageKey = "overlaysymphony:service:twitch"
+
+export function getCachedAuthentication(
+  scopes?: string[],
+): BareAuthentication | undefined {
+  const cache = localStorage.getItem(localStorageKey)
+  if (!cache) {
+    return undefined
+  }
+
+  const authentication = JSON.parse(cache) as BareAuthentication
+  authentication.expires = new Date(authentication.expires)
+
+  if (scopes) {
+    for (const scope of scopes) {
+      if (!authentication.scope.includes(scope)) {
+        localStorage.removeItem(localStorageKey)
+        return undefined
+      }
+    }
+  }
+
+  return authentication
 }
 
-interface TAResult {
-  token_type: "bearer"
-  access_token: string
-  scope: string
+export function setCachedAuthentication(
+  authentication: BareAuthentication,
+): void {
+  localStorage.setItem(localStorageKey, JSON.stringify(authentication))
 }
 
-const localStorageKey = "overlaysymphony:service:twitch"
+export function clearCachedAuthentication(): void {
+  localStorage.removeItem(localStorageKey)
+}
 
-export async function getAuthentication(): Promise<Authentication> {
-  const raw = localStorage.getItem(localStorageKey)
-  if (!raw) {
-    throw new Error("Twitch authentication missing!")
+export async function getAuthentication(
+  scopes?: string[],
+): Promise<Authentication | undefined> {
+  let authentication = getCachedAuthentication(scopes)
+  if (!authentication) {
+    return undefined
   }
 
-  const cached = JSON.parse(raw) as BareAuthentication
-  cached.expires = new Date(cached.expires)
+  try {
+    authentication = await validateAuthentication(authentication)
+  } catch (error) {
+    clearCachedAuthentication()
+    return undefined
+  }
 
-  const [user] = await getUsers(cached as Authentication)
+  const [user] = await getUsers(authentication as Authentication)
 
-  const authentication: Authentication = {
-    ...cached,
+  return {
+    ...authentication,
     user,
   }
+}
+
+export async function setAuthentication(
+  clientId: string,
+  accessToken: string,
+  scope: string[] = [],
+): Promise<BareAuthentication | undefined> {
+  let authentication: BareAuthentication = {
+    tokenType: "bearer",
+    clientId,
+    accessToken,
+    scope,
+
+    // this is ignored and replaced by validateAuthentication
+    expires: new Date(),
+  }
+
+  try {
+    authentication = await validateAuthentication(authentication)
+  } catch (error) {
+    return undefined
+  }
+
+  setCachedAuthentication(authentication)
 
   return authentication
 }
 
-export function initiateAuthentication(
+export async function popupAuthentication(
   clientId: string,
-  redirect: string,
-  scope: string[],
-): string {
-  return `https://id.twitch.tv/oauth2/authorize?${querystring.stringify({
-    response_type: "token",
-    client_id: clientId,
-    redirect_uri: redirect,
-    scope: scope.join("+"),
-    state: clientId,
-  })}`
+  scopes: string[],
+  popupUrl: string,
+): Promise<void> {
+  const url = new URL(
+    `${popupUrl}?scopes=${scopes.join("+")}&clientId=${clientId}`,
+  )
+
+  await new Promise<void>((resolve) => {
+    const listener = (event: MessageEvent) => {
+      if (event.origin !== url.origin) return
+
+      // const source = (event.source as Window | null)?.name
+      // if (source !== "OverlaySymphonyTwitchAuthenticationPopup") return
+
+      const { type, authentication } = event.data
+      if (type !== "authentication") return
+
+      window.removeEventListener("message", listener)
+
+      setCachedAuthentication(authentication as BareAuthentication)
+      resolve()
+    }
+
+    window.addEventListener("message", listener)
+
+    window.open(
+      url,
+      "OverlaySymphonyTwitchAuthenticationPopup",
+      "width=520,height=840",
+    )
+  })
 }
 
 export async function validateAuthentication(
@@ -76,7 +144,13 @@ export async function validateAuthentication(
     throw new Error(await response.text())
   }
 
-  const validated = (await response.json()) as TAValidation
+  const validated = (await response.json()) as {
+    client_id: string
+    login: string
+    scope: string[]
+    user_id: string
+    expires_in: number
+  }
 
   if (validated.client_id !== authentication.clientId) {
     throw new Error("ClientId mismatch.")
@@ -87,21 +161,3 @@ export async function validateAuthentication(
     expires: new Date(Date.now() + validated.expires_in * 1000),
   }
 }
-
-export async function authenticateResult(
-  clientId: string,
-  result: TAResult,
-): Promise<BareAuthentication> {
-  if (!result.token_type || !result.access_token || !result.scope) {
-    throw new Error("Invalid result.")
-  }
-
-  const authentication = await validateAuthentication({
-    clientId,
-    tokenType: result.token_type,
-    accessToken: result.access_token,
-    scope: result.scope.split("+"),
-  })
-
-  return authentication
-}

package/src/chat/chat.ts

@@ -1,9 +1,12 @@
 import createDefer from "@overlaysymphony/core/libs/defer"
 import createPubSub from "@overlaysymphony/core/libs/pubsub"
 
-import { Authentication } from "../authentication/index.js"
+import { type Authentication } from "../authentication/index.js"
 
-import { TwitchChatEvent, TwitchChatEventType } from "./interfaces/index.js"
+import {
+  type TwitchChatEvent,
+  type TwitchChatEventType,
+} from "./interfaces/index.js"
 import parseCommand from "./parser.js"
 
 type ChatListener = (callback: (event: TwitchChatEvent) => void) => () => void
@@ -22,7 +25,7 @@ type ChatMessageSubscriber = (
   callback: (event: TwitchChatEvent<"PRIVMSG">) => void,
 ) => () => void
 
-type ChatCommandSubscriber = {
+interface ChatCommandSubscriber {
   (
     callback: (event: TwitchChatEvent<"PRIVMSG-COMMAND">) => void,
     name?: never,
@@ -67,8 +70,7 @@ export async function createChat(
         command.type === "JOIN" ||
         command.type === "USERSTATE" ||
         command.type === "HOSTTARGET" ||
-        command.type === "NOTICE" ||
-        false
+        command.type === "NOTICE"
       ) {
         continue
       }
@@ -106,16 +108,15 @@ export async function createChat(
   return promise.then(() => {
     const listen: ChatListener = (callback) => {
       return pubsub.subscribe((event) => {
-        // @ts-ignore
         callback(event)
       })
     }
 
     const subscribe: ChatSubscriber = (types, callback) => {
       return pubsub.subscribe((event) => {
-        // @ts-ignore
+        // @ts-expect-error: generic events are complicated
         if (types.includes(event.type)) {
-          // @ts-ignore
+          // @ts-expect-error: generic events are complicated
           callback(event)
         }
       })

package/src/chat/helpers.ts

@@ -0,0 +1,36 @@
+interface ApplicableChatEvent {
+  tags?: {
+    mod?: boolean
+    badges?: {
+      broadcaster?: boolean
+    }
+  }
+}
+
+export function isBroadcaster(event: ApplicableChatEvent): boolean | null {
+  const broadcaster = event.tags?.badges?.broadcaster
+
+  if (typeof broadcaster === "undefined") return null
+
+  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
+
+  return broadcaster || mod
+}
+
+export function isModOnly(event: ApplicableChatEvent): boolean | null {
+  const broadcaster = event.tags?.badges?.broadcaster
+  const mod = event.tags?.mod
+
+  if (typeof broadcaster === "undefined" || typeof mod === "undefined")
+    return null
+
+  return mod && !broadcaster
+}

package/src/chat/index.ts

@@ -4,3 +4,4 @@ export type {
 } from "./interfaces/index.js"
 
 export * from "./chat.js"
+export * from "./helpers.js"

package/src/chat/interfaces/events.ts

@@ -13,20 +13,20 @@ type TagEmotes = Record<
   Array<[startPosition: string, endPosition: string]>
 >
 
-export type PingEvent = {
+export interface PingEvent {
   type: "PING"
   message: string
   source?: ChatEventSource
 }
 
-export type WelcomeEvent = {
+export interface WelcomeEvent {
   type: "001" // Logged in (successfully authenticated)
   channel: string
   message: string
   source?: ChatEventSource
 }
 
-export type CapabilitiesEvent = {
+export interface CapabilitiesEvent {
   type: "CAP"
   enabled: boolean
   nickname: string
@@ -34,21 +34,21 @@ export type CapabilitiesEvent = {
   source?: ChatEventSource
 }
 
-export type JoinEvent = {
+export interface JoinEvent {
   type: "JOIN"
   channel: string
   source?: ChatEventSource
 }
 
-export type PartEvent = {
+export interface PartEvent {
   type: "PART"
   channel: string
   source?: ChatEventSource
 }
 
-export type GlobalUserStateEvent = {
+export interface GlobalUserStateEvent {
   type: "GLOBALUSERSTATE"
-  tags: {
+  tags?: {
     userId: string
     userType: TagUserType
     displayName?: string
@@ -60,15 +60,15 @@ export type GlobalUserStateEvent = {
   source?: ChatEventSource
 }
 
-export type ReconnectEvent = {
+export interface ReconnectEvent {
   type: "RECONNECT"
   source?: ChatEventSource
 }
 
-export type ClearChatEvent = {
+export interface ClearChatEvent {
   type: "CLEARCHAT"
   channel: string
-  tags: {
+  tags?: {
     roomId: string
     targetUserId: string
     banDuration: number
@@ -76,26 +76,26 @@ export type ClearChatEvent = {
   source?: ChatEventSource
 }
 
-export type HostTargetEvent = {
+export interface HostTargetEvent {
   type: "HOSTTARGET"
   channel: string
   source?: ChatEventSource
 }
 
-export type NoticeEvent = {
+export interface NoticeEvent {
   type: "NOTICE"
   channel: string
-  tags: {
+  tags?: {
     msgId: string
     targetUserId: string
   }
   source?: ChatEventSource
 }
 
-export type RoomStateEvent = {
+export interface RoomStateEvent {
   type: "ROOMSTATE"
   channel: string
-  tags: {
+  tags?: {
     roomId: string
     slow: number
     emoteOnly: boolean
@@ -105,10 +105,10 @@ export type RoomStateEvent = {
   source?: ChatEventSource
 }
 
-export type UserStateEvent = {
+export interface UserStateEvent {
   type: "USERSTATE"
   channel: string
-  tags: {
+  tags?: {
     id: string
     userId: string
     userType: TagUserType
@@ -126,10 +126,10 @@ export type UserStateEvent = {
   source?: ChatEventSource
 }
 
-export type ClearMessageEvent = {
+export interface ClearMessageEvent {
   type: "CLEARMSG"
   channel: string
-  tags: {
+  tags?: {
     login: string
     roomId: string
     targetMsgId?: string
@@ -137,10 +137,10 @@ export type ClearMessageEvent = {
   source?: ChatEventSource
 }
 
-export type UserNoticeEvent = {
+export interface UserNoticeEvent {
   type: "USERNOTICE"
   channel: string
-  tags: {
+  tags?: {
     id: string
     userId: string
     userType: TagUserType
@@ -173,11 +173,11 @@ export type UserNoticeEvent = {
   source?: ChatEventSource
 }
 
-export type ChatMessageEvent = {
+export interface ChatMessageEvent {
   type: "PRIVMSG"
   channel: string
   message: string
-  tags: {
+  tags?: {
     id: string
     userId: string
     userType: TagUserType
@@ -212,11 +212,11 @@ export type ChatMessageEvent = {
   source?: ChatEventSource
 }
 
-export type WhisperMessageEvent = {
+export interface WhisperMessageEvent {
   type: "WHISPER"
   channel: string
   message: string
-  tags: {
+  tags?: {
     messageId: string
     threadId: string
     userId: string
@@ -230,21 +230,21 @@ export type WhisperMessageEvent = {
   source?: ChatEventSource
 }
 
-export type ChatCommandEvent = {
+export interface ChatCommandEvent {
   type: "PRIVMSG-COMMAND"
   channel: string
   command: string
   parameters?: string
-  tags: ChatMessageEvent["tags"]
+  tags?: ChatMessageEvent["tags"]
   source?: ChatEventSource
 }
 
-export type WhisperCommandEvent = {
+export interface WhisperCommandEvent {
   type: "WHISPER-COMMAND"
   channel: string
   command: string
   parameters?: string
-  tags: WhisperMessageEvent["tags"]
+  tags?: WhisperMessageEvent["tags"]
   source?: ChatEventSource
 }
 

package/src/chat/interfaces/index.ts

@@ -1,4 +1,4 @@
-import { ChatEvent } from "./events.js"
+import { type ChatEvent } from "./events.js"
 
 export type { ChatEvent, ChatEventSource } from "./events.js"