multichat-ts 0.0.82 → 0.0.84

package/dist/worker/index.d.ts

@@ -0,0 +1,144 @@
+export * from './kick.js';
+export * from './twitch.js';
+export type Message = {
+    body: BodyComponent[];
+    channel: {
+        room_id: string;
+        name: string;
+    };
+    id: string;
+    raw_text: string;
+    timestamp_sent: number;
+    user: {
+        badges: Badge[];
+        color: string;
+        id: string;
+        username: string;
+        display_name: string;
+        roles: {
+            [role in 'vip' | 'moderator' | 'turbo' | 'admin' | 'global_moderator' | 'staff']?: boolean;
+        };
+    };
+};
+export type ClearMessages = {
+    channel: {
+        room_id: string;
+        name: string;
+    };
+    user?: {
+        id: string;
+        username: string;
+    };
+    timeout_duration_seconds?: number | undefined;
+    timestamp_sent: number;
+};
+export type DeleteMessage = {
+    channel: {
+        room_id?: string;
+        name: string;
+    };
+    user?: {
+        username: string;
+    };
+    id: string;
+    raw_text: string;
+    timestamp_sent: number;
+};
+type EventData = {
+    subscription: {
+        months: number;
+        streak?: number;
+        subscription_plan: {
+            type: 'prime' | 1000 | 2000 | 3000;
+            name: string;
+        };
+        gift_upgrade?: {
+            gift_total: number;
+            promo_name: string;
+            sender: {
+                username: string;
+                display_name: string;
+            };
+        };
+    };
+    gift: {
+        months: number;
+        recipient: {
+            id: string;
+            username: string;
+            display_name: string;
+        };
+        subscription_plan: {
+            type: 'prime' | 1000 | 2000 | 3000;
+            name: string;
+        };
+    };
+    raid: {
+        sender: {
+            username: string;
+            display_name: string;
+            viewer_count: number;
+        };
+    };
+};
+export type Event = {
+    [E in keyof EventData]: {
+        type: E;
+        body: BodyComponent[];
+        channel: {
+            room_id: string;
+            name: string;
+        };
+        id: string;
+        raw_text: string;
+        system_message: string;
+        timestamp_sent: number;
+        user: {
+            badges: Badge[];
+            color: string;
+            id: string;
+            username: string;
+            display_name: string;
+            roles: {
+                [role in 'moderator' | 'subscriber' | 'turbo' | 'admin' | 'global_moderator' | 'staff']?: boolean;
+            };
+        };
+        data: EventData[E];
+    };
+}[keyof EventData];
+export type BodyComponentEmote = {
+    end_exclusive: number;
+    start_inclusive: number;
+    type: 'emote';
+    url: string;
+};
+export type BodyComponent = {
+    end_exclusive: number;
+    label: string;
+    start_inclusive: number;
+    type: 'link';
+    url: string;
+} | {
+    end_exclusive: number;
+    start_inclusive: number;
+    text: string;
+    type: 'text';
+} | BodyComponentEmote;
+type Badge = {
+    info?: string | undefined;
+    set_id: string;
+    url: string;
+};
+export type BadgeURLsByNameOrCount = {
+    [badge_name: string]: string | {
+        [badge_count: number]: string;
+    };
+};
+export type BadgeURLsBySetIDOrSetIDAndVersion = {
+    [set_id: string]: {
+        [version: string]: string;
+    } | string;
+};
+export type EmoteURLsByName = {
+    [emote_name: string]: string;
+};

package/dist/worker/index.js

@@ -0,0 +1,2 @@
+export * from './kick.js';
+export * from './twitch.js';

package/dist/worker/kick.d.ts

@@ -0,0 +1,192 @@
+import Pusher from 'pusher-js/worker';
+import { type BadgeURLsByNameOrCount, type EmoteURLsByName, type Message } from './index.js';
+type EventCallbackFunctions = {
+    message: (message: Message) => unknown;
+    subscription: (data: ChatSubscriptionEvent) => unknown;
+    gifted: (data: ChatGiftedEvent) => unknown;
+    raw_message: (message: ChatMessageEvent) => unknown;
+};
+type EventNames = keyof EventCallbackFunctions;
+export declare class KickPusher {
+    kick_pusher_key: string;
+    channel_name?: string;
+    private assets;
+    private public_listeners;
+    socket?: Pusher;
+    isConnected: boolean;
+    setBadges(badges: BadgeURLsByNameOrCount): void;
+    setExternalEmotes(external_emotes: EmoteURLsByName): void;
+    getStoredBadges(): BadgeURLsByNameOrCount;
+    getStoredExternalEmotes(): EmoteURLsByName;
+    connect(channel?: {
+        channelName?: string;
+    }): Promise<void>;
+    disconnect(): void;
+    on<EventName extends EventNames>(event_name: EventName, callback_fn: EventCallbackFunctions[EventName]): void;
+    private onSubscriptionSuccess;
+    private onChatSubscription;
+    private onChatGifted;
+    private onChatMessage;
+}
+export interface GetChannelResponse {
+    id: number;
+    user_id: number;
+    slug: string;
+    is_banned: boolean;
+    playback_url?: string;
+    vod_enabled: boolean;
+    subscription_enabled: boolean;
+    followers_count: number;
+    following?: boolean;
+    subscription?: unknown;
+    subscriber_badges: Array<{
+        id: number;
+        channel_id: number;
+        months: number;
+        badge_image: {
+            srcset: string;
+            src: string;
+        };
+    }>;
+    banner_image?: {
+        url: string;
+    };
+    livestream?: ChannelLivestream;
+    role?: unknown;
+    muted: boolean;
+    follower_badges: unknown[];
+    offline_banner_image: unknown;
+    verified: boolean;
+    recent_categories: Array<{
+        id: number;
+        category_id: number;
+        name: string;
+        slug: string;
+        tags: string[];
+        description?: string;
+        deleted_at: unknown;
+        viewers: number;
+        banner: {
+            responsive: string;
+            url: string;
+        };
+        category: {
+            id: number;
+            name: string;
+            slug: string;
+            icon: string;
+        };
+    }>;
+    can_host: boolean;
+    user: {
+        id: number;
+        username: string;
+        agreed_to_terms: true;
+        email_verified_at: Date;
+        bio?: string;
+        country?: string;
+        state?: string;
+        city?: string;
+        instagram?: string;
+        twitter?: string;
+        youtube?: string;
+        discord?: string;
+        tiktok?: string;
+        facebook?: string;
+        profile_pic?: string;
+    };
+    chatroom: ChannelChatroom;
+    ascending_links?: Array<{
+        id: number;
+        channel_id: number;
+        description: string;
+        link: string;
+        created_at: Date;
+        updated_at: Date;
+        order: number;
+        title: string;
+    }>;
+}
+export interface ChannelLivestream {
+    id: number;
+    slug: string;
+    channel_id: number;
+    created_at: Date;
+    session_title: string;
+    is_live: boolean;
+    risk_level_id: unknown;
+    start_time: Date;
+    source: unknown;
+    twitch_channel: unknown;
+    duration: number;
+    language: string;
+    is_mature: boolean;
+    viewer_count: number;
+    thumbnail: {
+        url: string;
+    };
+    categories: Array<{
+        id: number;
+        category_id: number;
+        name: string;
+        slug: string;
+        tags: string[];
+        description?: string;
+        deleted_at: unknown;
+        viewers: number;
+        category: {
+            id: number;
+            name: string;
+            slug: string;
+            icon: string;
+        };
+    }>;
+    tags: unknown[];
+}
+export interface ChannelChatroom {
+    id: number;
+    chatable_type: string;
+    channel_id: string;
+    created_at: Date;
+    updated_at: Date;
+    chat_mode_old: string;
+    chat_mode: string;
+    slow_mode: boolean;
+    chatable_id: number;
+    followers_mode: boolean;
+    subscribers_mode: boolean;
+    emotes_mode: boolean;
+    message_interval: number;
+    following_min_duration: number;
+}
+export interface ChatMessageEvent {
+    id: string;
+    chatroom_id: number;
+    content: string;
+    type: string;
+    created_at: string;
+    sender: {
+        id: number;
+        username: string;
+        slug?: string;
+        identity: {
+            color: string;
+            badges: Array<{
+                type: string;
+                text: string;
+                count?: number;
+            }>;
+        };
+    };
+}
+export interface ChatSubscriptionEvent {
+    chatroom_id: string;
+    username: string;
+    months: number;
+}
+export interface ChatGiftedEvent {
+    chatroom_id: string;
+    gifted_usernames: string[];
+    gifter_username: string;
+}
+export {};

package/dist/worker/kick.js

@@ -0,0 +1,182 @@
+import Pusher from 'pusher-js/worker';
+const DEFAULT_KICK_PUSHER_KEY = '32cbd69e4b950bf97679';
+export class KickPusher {
+    kick_pusher_key = DEFAULT_KICK_PUSHER_KEY;
+    channel_name;
+    assets = {
+        external_emotes: {},
+        badges: {
+            founder: '/svgs/badges/default-kick/founder.svg',
+            moderator: '/svgs/badges/default-kick/moderator.svg',
+            og: '/svgs/badges/default-kick/og.svg',
+            sub_gifter: {
+                1: '/svgs/badges/default-kick/sub-gifter-blue.svg',
+                25: '/svgs/badges/default-kick/sub-gifter-purple.svg',
+                50: '/svgs/badges/default-kick/sub-gifter-red.svg',
+                100: '/svgs/badges/default-kick/sub-gifter-yellow.svg',
+                200: '/svgs/badges/default-kick/sub-gifter-green.svg',
+            },
+            verified: '/svgs/badges/default-kick/verified.svg',
+            vip: '/svgs/badges/default-kick/vip.svg',
+            broadcaster: '/svgs/badges/default-kick/broadcaster.svg',
+            staff: '/svgs/badges/default-kick/staff.svg',
+        },
+    };
+    public_listeners = {};
+    socket;
+    isConnected = false;
+    setBadges(badges) {
+        this.assets.badges = { ...this.assets.badges, ...badges };
+    }
+    setExternalEmotes(external_emotes) {
+        this.assets.external_emotes = { ...this.assets.external_emotes, ...external_emotes };
+    }
+    getStoredBadges() {
+        return this.assets.badges;
+    }
+    getStoredExternalEmotes() {
+        return this.assets.external_emotes;
+    }
+    async connect(channel) {
+        if (channel?.channelName)
+            this.channel_name = channel.channelName;
+        if (!this.channel_name)
+            return console.error('channel_name not specified');
+        console.log(`connecting to ${this.channel_name}...`);
+        const channel_response = await fetch(`https://kick.com/api/v2/channels/${this.channel_name}`, {
+            headers: {
+                accept: 'aplication/json',
+                'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36',
+            },
+        })
+            .then((res) => res.json())
+            .then((json) => json);
+        if (!channel_response)
+            return console.error('Failed to connect to Kick.com chat');
+        channel_response.subscriber_badges.forEach((subscriber_badge) => {
+            this.assets.badges['subscriber'] = {
+                ...(this.assets.badges['subscriber'] ?? {}),
+                [subscriber_badge.months]: subscriber_badge.badge_image.src,
+            };
+        });
+        this.disconnect();
+        this.socket = new Pusher(this.kick_pusher_key, {
+            cluster: 'us2',
+        });
+        this.socket
+            .subscribe(`chatrooms.${channel_response.chatroom.id}.v2`)
+            .bind('pusher:subscription_succeeded', () => this.onSubscriptionSuccess())
+            .bind('App\\Events\\ChatMessageEvent', (data) => this.onChatMessage(data))
+            .bind('App\\Events\\SubscriptionEvent', (data) => this.onChatSubscription(data))
+            .bind('App\\Events\\GiftedSubscriptionsEvent', (data) => this.onChatGifted(data));
+    }
+    disconnect() {
+        this.socket?.disconnect();
+        this.socket?.unbind_all();
+    }
+    on(event_name, callback_fn) {
+        this.public_listeners[event_name] = callback_fn;
+    }
+    onSubscriptionSuccess() {
+        console.log(`Connected to Kick Pusher (${this.channel_name})`);
+    }
+    onChatSubscription(data) {
+        this.public_listeners.subscription?.(data);
+    }
+    onChatGifted(data) {
+        this.public_listeners.gifted?.(data);
+    }
+    onChatMessage(data) {
+        this.public_listeners.raw_message?.(data);
+        const text = data.content;
+        const emote_matches = [...data.content.matchAll(/\[emote:\d+:[a-zA-Z0-9]*\]/g)];
+        console.log(emote_matches);
+        const body = [];
+        emote_matches.forEach((match) => {
+            const emote_string = match[0];
+            const emote_parts = emote_string.slice(1, emote_string.length - 1).split(':');
+            const emote_id = emote_parts[1];
+            if (!emote_id)
+                return;
+            console.log(emote_id);
+            body.push({
+                type: 'emote',
+                start_inclusive: match.index,
+                end_exclusive: match.index + emote_string.length,
+                url: `https://files.kick.com/emotes/${emote_id}/fullsize`,
+            });
+        });
+        body.sort((a, b) => a.start_inclusive - b.start_inclusive);
+        const old_body_length = body.length;
+        if (old_body_length > 0) {
+            body.forEach((segment, index) => {
+                const previous_segment = body[index - 1];
+                const text_start_inclusive = previous_segment?.end_exclusive !== undefined ? previous_segment.end_exclusive + 1 : 0;
+                const text_end_exclusive = Math.max(0, segment.start_inclusive);
+                if (text_end_exclusive - text_start_inclusive > 0) {
+                    body.push({
+                        type: 'text',
+                        text: text.slice(text_start_inclusive, text_end_exclusive),
+                        start_inclusive: text_start_inclusive,
+                        end_exclusive: text_end_exclusive,
+                    });
+                }
+                if (index === old_body_length - 1 && segment.end_exclusive < text.length - 1) {
+                    body.push({
+                        type: 'text',
+                        text: text.slice(segment.end_exclusive),
+                        start_inclusive: segment.end_exclusive,
+                        end_exclusive: text.length,
+                    });
+                }
+            });
+        }
+        else {
+            body.push({
+                type: 'text',
+                text,
+                start_inclusive: 0,
+                end_exclusive: text.length,
+            });
+        }
+        body.sort((a, b) => a.start_inclusive - b.start_inclusive);
+        this.public_listeners.message?.({
+            id: data.id,
+            user: {
+                id: `${data.sender.id}`,
+                username: data.sender.slug ?? data.sender.username.toLowerCase(),
+                display_name: data.sender.username,
+                roles: {},
+                color: data.sender.identity.color,
+                badges: data.sender.identity.badges.flatMap((badge) => {
+                    let badge_url = undefined;
+                    const badge_url_or_counts = this.assets.badges[badge.type];
+                    const badge_count = badge.count;
+                    if (typeof badge_url_or_counts === 'string')
+                        badge_url = badge_url_or_counts;
+                    else if (typeof badge_url_or_counts === 'object' && badge_count !== undefined) {
+                        const badge_entry_by_count = Object.entries(badge_url_or_counts)
+                            .sort(([a_min_count], [b_min_count]) => Number(a_min_count) - Number(b_min_count))
+                            .find(([min_count]) => badge_count >= Number(min_count));
+                        if (badge_entry_by_count)
+                            badge_url = badge_entry_by_count[1];
+                    }
+                    if (!badge_url)
+                        return [];
+                    return {
+                        set_id: badge.type,
+                        url: badge_url,
+                        info: String(badge.count),
+                    };
+                }),
+            },
+            body,
+            channel: {
+                room_id: String(data.chatroom_id),
+                name: this.channel_name ?? 'unknown',
+            },
+            raw_text: data.content,
+            timestamp_sent: Date.parse(data.created_at),
+        });
+    }
+}

package/dist/worker/twitch.d.ts

@@ -0,0 +1,73 @@
+import { WebSocket } from 'partysocket';
+import { type ClearMessages, type DeleteMessage, type Message, type Event, type EmoteURLsByName, type BadgeURLsBySetIDOrSetIDAndVersion } from './index.js';
+type EventCallbackFunctions = {
+    message: (message: Message) => unknown;
+    clear_messages: (data: ClearMessages) => unknown;
+    delete_message: (data: DeleteMessage) => unknown;
+    event: (event: Event) => unknown;
+    raw_message: (message: IRC_Message) => unknown;
+};
+type EventNames = keyof EventCallbackFunctions;
+export declare class TwitchIRC {
+    channel_name?: string;
+    private assets;
+    latency: number;
+    private ping;
+    private public_listeners;
+    socket?: WebSocket;
+    ws?: WebSocket | undefined;
+    constructor(ws?: WebSocket);
+    setBadges(badges: BadgeURLsBySetIDOrSetIDAndVersion): void;
+    setExternalEmotes(external_emotes: EmoteURLsByName): void;
+    getStoredBadges(): BadgeURLsBySetIDOrSetIDAndVersion;
+    getStoredExternalEmotes(): EmoteURLsByName;
+    connect(channel?: {
+        channelName?: string;
+    }): void;
+    disconnect(): void;
+    on<EventName extends EventNames>(event_name: EventName, callback_fn: EventCallbackFunctions[EventName]): void;
+    isConnected(): this is {
+        socket: {
+            readyState: typeof WebSocket.OPEN;
+        } & WebSocket;
+    };
+    private onOpen;
+    private onClose;
+    private sendPing;
+    private send;
+    private onMessage;
+}
+type IRC_Message = {
+    [C in CommandType]: {
+        channel: string;
+        command: C;
+        params: string[];
+        source: RawSource | undefined;
+        tags: SpecificRawTags<C> | undefined;
+    };
+}[CommandType];
+type RAW_TAGS = typeof RAW_TAGS;
+type CommandType = keyof RAW_TAGS;
+type SpecificRawTags<Command extends CommandType> = Record<RAW_TAGS[Command][number], string | undefined>;
+type RawSource = {
+    host: string;
+    nick?: string | undefined;
+    user?: string | undefined;
+};
+declare const RAW_TAGS: {
+    readonly CLEARCHAT: readonly ["ban-duration", "room-id", "target-user-id", "tmi-sent-ts"];
+    readonly CLEARMSG: readonly ["login", "room-id", "target-msg-id", "tmi-sent-ts"];
+    readonly GLOBALUSERSTATE: readonly ["badge-info", "badges", "color", "display-name", "emote-sets", "turbo", "user-id", "user-type"];
+    readonly HOSTTARGET: readonly [];
+    readonly NOTICE: readonly ["msg-id", "target-user-id"];
+    readonly PART: readonly [];
+    readonly PING: readonly [];
+    readonly PONG: readonly [];
+    readonly PRIVMSG: readonly ["badge-info", "badges", "bits", "color", "display-name", "emotes", "emote-only", "id", "mod", "custom-reward-id", "reply-thread-parent-display-name", "reply-thread-parent-user-id", "pinned-chat-paid-amount", "pinned-chat-paid-currency", "pinned-chat-paid-exponent", "pinned-chat-paid-level", "pinned-chat-paid-is-system-message", "reply-parent-msg-id", "reply-parent-user-id", "reply-parent-user-login", "reply-parent-display-name", "reply-parent-msg-body", "reply-thread-parent-msg-id", "reply-thread-parent-user-login", "room-id", "subscriber", "tmi-sent-ts", "turbo", "user-id", "user-type", "vip", "client-nonce", "first-msg", "flags", "returning-chatter"];
+    readonly RECONNECT: readonly [];
+    readonly ROOMSTATE: readonly ["emote-only", "followers-only", "r9k", "room-id", "slow", "subs-only"];
+    readonly USERNOTICE: readonly ["badge-info", "badges", "color", "display-name", "emotes", "id", "login", "mod", "msg-id", "room-id", "subscriber", "system-msg", "tmi-sent-ts", "turbo", "user-id", "user-type", "vip", "flags", "msg-param-cumulative-months", "msg-param-displayName", "msg-param-login", "msg-param-multimonth-duration", "msg-param-multimonth-tenure", "msg-param-was-gifted=false", "msg-param-months", "msg-param-promo-gift-total", "msg-param-promo-name", "msg-param-recipient-display-name", "msg-param-recipient-id", "msg-param-recipient-user-name", "msg-param-sender-login", "msg-param-sender-name", "msg-param-should-share-streak", "msg-param-streak-months", "msg-param-sub-plan", "msg-param-sub-plan-name", "msg-param-viewerCount", "msg-param-ritual-name", "msg-param-threshold", "msg-param-gift-months", "msg-param-was-gifted", "msg-param-community-gift-id", "msg-param-mass-gift-count", "msg-param-origin-id"];
+    readonly USERSTATE: readonly ["badge-info", "badges", "color", "display-name", "emote-sets", "id", "mod", "subscriber", "turbo", "user-type"];
+    readonly WHISPER: readonly ["badges", "color", "display-name", "emotes", "message-id", "thread-id", "turbo", "user-id", "user-type"];
+};
+export {};