@tixyel/streamelements 7.6.5 → 7.6.7

package/README.md

@@ -19,11 +19,11 @@ Add the following to your HTML:
 <script>
   const { Client, Simulation, logger } = window.Tixyel;
 
-  const client = new Client({ id: 'my-widget' })
+  const client = new Client({ id: "my-widget" });
 
-  client.on('load', (event) => {})
-  client.on('event', (provider, event) => {})
-  client.on('session', (session) => {})
+  client.on("load", (event) => {});
+  client.on("event", (provider, event) => {});
+  client.on("session", (session) => {});
 </script>
 ```
 

package/dist/index.d.ts

@@ -7,240 +7,6 @@
 import { ComfyJSInstance, OnErrorHandler, OnCommandHandler, OnChatHandler, OnWhisperHandler, OnMessageDeletedHandler, OnJoinHandler, OnPartHandler, OnHostedHandler, OnRaidHandler, OnSubHandler, OnResubHandler, OnSubGiftHandler, OnSubMysteryGiftHandler, OnGiftSubContinueHandler, OnCheerHandler, OnChatModeHandler, OnRewardHandler, OnConnectedHandler, OnReconnectHandler } from 'comfy.js';
 export { ComfyJSInstance } from 'comfy.js';
 
-type Provider$1 = 'twitch' | 'youtube' | 'kick' | 'facebook' | 'streamelements';
-type ClientProviderEvents = {
-    streamelements: StreamElements.Event.Provider.StreamElements.Events;
-    twitch: StreamElements.Event.Provider.Twitch.Events;
-    youtube: StreamElements.Event.Provider.YouTube.Events;
-    kick: StreamElements.Event.Provider.Kick.Events;
-    facebook: StreamElements.Event.Provider.Facebook.Events;
-};
-type ClientCustomEventPayload<TProvider extends string = string> = {
-    provider: TProvider;
-};
-type ClientCustomProviderEvents = Record<string, ClientCustomEventPayload>;
-type ClientCustomEventsWithoutInternalProviders<CustomEvents> = Omit<CustomEvents, keyof ClientProviderEvents>;
-type ValidateCustomProviderEvents<CustomEvents> = CustomEvents extends Record<string, unknown> ? {
-    [K in keyof ClientCustomEventsWithoutInternalProviders<CustomEvents> & string]: ClientCustomEventsWithoutInternalProviders<CustomEvents>[K] extends ClientCustomEventPayload<K> ? ClientCustomEventsWithoutInternalProviders<CustomEvents>[K] : never;
-} : {};
-type ClientAllProviderEvents<CustomEvents = {}> = ClientProviderEvents & ValidateCustomProviderEvents<CustomEvents>;
-type ClientEvents<CustomEvents = {}> = {
-    [K in keyof ClientAllProviderEvents<CustomEvents> & string]: {
-        provider: K;
-        data: ClientAllProviderEvents<CustomEvents>[K];
-    };
-}[keyof ClientAllProviderEvents<CustomEvents> & string];
-type ClientEventTuple<CustomEvents = {}> = {
-    [K in keyof ClientAllProviderEvents<CustomEvents> & string]: [
-        provider: K,
-        event: ClientAllProviderEvents<CustomEvents>[K]
-    ];
-}[keyof ClientAllProviderEvents<CustomEvents> & string];
-
-declare namespace StreamElementsEvents {
-    namespace Tip {
-        type Data = {
-            listener: 'tip-latest';
-            event: Event;
-        };
-        type Event = {
-            amount: number;
-            avatar: string;
-            name: string;
-            displayName: string;
-            providerId: string;
-            _id: string;
-            sessionTop: boolean;
-            type: 'tip';
-            originalEventName: 'tip-latest';
-        };
-    }
-    namespace KVStore {
-        type Data = {
-            listener: 'kvstore:update';
-            event: Event;
-        };
-        type Event = {
-            data: {
-                key: `customWidget.${string}`;
-                value: string | number | boolean | Record<string, any>;
-            };
-        };
-    }
-    namespace BotCounter {
-        type Data = {
-            listener: 'bot:counter';
-            event: Event;
-        };
-        type Event = {
-            counter: string;
-            value: number;
-        };
-    }
-    namespace AlertService {
-        type Data = {
-            listener: 'alertService:toggleSound';
-            event: Event;
-        };
-        type Event = {
-            muted: boolean;
-        };
-    }
-    namespace EventSkip {
-        type Data = {
-            listener: 'event:skip';
-            event: Event;
-        };
-        type Event = {};
-    }
-    namespace EventTest {
-        export type Data = {
-            listener: 'event:test';
-            event: Event;
-        };
-        export type Event = widgetButton | emulatedEvents<EventType> | Session;
-        type items = {
-            name: string;
-            price: number;
-            quantity: number;
-        };
-        type widgetButton = {
-            listener: 'widget-button';
-            field: string;
-            value: string | number | boolean;
-        };
-        type EventType = 'follower' | 'subscriber' | 'tip' | 'cheer' | 'raid';
-        type EventTier = 'prime' | '1000' | '2000' | '3000';
-        type emulatedEvents<T extends EventType> = {
-            listener: `${T}-latest`;
-            event: {
-                type: T;
-                name: string;
-                amount: number;
-                count: number;
-                message?: string;
-                gifted?: boolean;
-                bulkGifted?: boolean;
-                sender?: string;
-                subExtension?: boolean;
-                items: items[];
-                tier: EventTier;
-                month: string;
-                isTest: true;
-            };
-        };
-        type Session = SessionCount | SessionTotal | SessionTop | SessionGoal | SessionRecent | SessionPoints;
-        type SessionCount = {
-            listener: `${EventType}-count`;
-            event: {
-                type: EventType;
-                name: string;
-                count: number;
-                items: items[];
-                tier: EventTier;
-                month: string;
-                isTest: true;
-            };
-        };
-        type SessionTotal = {
-            listener: `${EventType}-total`;
-            event: {
-                type: EventType;
-                name: string;
-                amount: number;
-                count: number;
-                items: items[];
-                tier: EventTier;
-                month: string;
-                isTest: true;
-            };
-        };
-        type SessionTop = {
-            listener: `${EventType}-top`;
-            event: {
-                type: EventType;
-                name: string;
-                amount: number;
-                count: number;
-                items: items[];
-                tier: EventTier;
-                month: string;
-                isTest: true;
-            };
-        };
-        type SessionGoal = {
-            listener: `${EventType}-goal`;
-            event: {
-                type: EventType;
-                name: string;
-                amount: number;
-                count: number;
-                items: items[];
-                tier: EventTier;
-                month: string;
-                isTest: true;
-            };
-        };
-        type SessionRecent = {
-            listener: `${EventType}-recent`;
-            event: {
-                event: SessionRecentEvent[];
-            };
-        };
-        type SessionRecentEvent = {
-            type: EventType;
-            name: string;
-            amount: number;
-            count: number;
-            tier: EventTier;
-            isTest: true;
-        };
-        type SessionPoints = {
-            listener: `${EventType}-points`;
-            event: {
-                type: EventType;
-                name: string;
-                amount: number;
-                count: number;
-                items: items[];
-                tier: EventTier;
-                month: string;
-                isTest: true;
-            };
-        };
-        export {};
-    }
-    interface BaseEvent {
-        provider: Provider$1;
-        flagged: boolean;
-        channel: string;
-        createdAt: string;
-        _id: string;
-        expiresAt: string;
-        updatedAt: string;
-        activityId: string;
-        sessionEventsCount: number;
-        isMock?: boolean;
-    }
-    namespace Event {
-        type Data = {
-            listener: 'event';
-            event: Event;
-        };
-        type Event = Tip;
-        interface Tip extends BaseEvent {
-            type: 'tip';
-            data: {
-                amount: string;
-                currency: string;
-                username: string;
-                message: string;
-                avatar: string;
-            };
-        }
-    }
-}
-
 type TwitchEmote = {
     type: 'twitch';
     name: string;
@@ -510,20 +276,20 @@ declare namespace TwitchEvents {
                 time: number;
                 tags: Partial<MapNumberValuesToString<Twitch.IRC>> & {
                     'badge-info': string;
-                    'badges': string;
+                    badges: string;
                     'client-nonce': string;
-                    'color': string;
+                    color: string;
                     'display-name': string;
-                    'emotes': string;
+                    emotes: string;
                     'first-msg': '1' | '0';
-                    'flags': string;
-                    'id': string;
-                    'mod': '1' | '0';
+                    flags: string;
+                    id: string;
+                    mod: '1' | '0';
                     'returning-chatter': '1' | '0';
                     'room-id': string;
-                    'subscriber': '1' | '0';
+                    subscriber: '1' | '0';
                     'tmi-sent-ts': string;
-                    'turbo': '1' | '0';
+                    turbo: '1' | '0';
                     'user-id': string;
                     'user-type': '' | 'mod' | 'admin' | 'global_mod' | 'staff';
                 };
@@ -1693,6 +1459,252 @@ declare namespace StreamElements {
     }
 }
 
+type Provider$1 = 'twitch' | 'youtube' | 'kick' | 'facebook' | 'streamelements';
+type ClientProviderEvents = {
+    streamelements: StreamElements.Event.Provider.StreamElements.Events;
+    twitch: StreamElements.Event.Provider.Twitch.Events;
+    youtube: StreamElements.Event.Provider.YouTube.Events;
+    kick: StreamElements.Event.Provider.Kick.Events;
+    facebook: StreamElements.Event.Provider.Facebook.Events;
+};
+type ClientCustomEventPayload<TProvider extends string = string> = {
+    provider: TProvider;
+};
+type ClientCustomProviderEvents = Record<string, ClientCustomEventPayload>;
+type ClientCustomEventsWithoutInternalProviders<CustomEvents> = Omit<CustomEvents, keyof ClientProviderEvents>;
+type ValidateCustomProviderEvents<CustomEvents> = CustomEvents extends Record<string, unknown> ? {
+    [K in keyof ClientCustomEventsWithoutInternalProviders<CustomEvents> & string]: ClientCustomEventsWithoutInternalProviders<CustomEvents>[K] extends ClientCustomEventPayload<K> ? ClientCustomEventsWithoutInternalProviders<CustomEvents>[K] : never;
+} : {};
+type ClientAllProviderEvents<CustomEvents = {}> = ClientProviderEvents & ValidateCustomProviderEvents<CustomEvents>;
+type ClientEvents<CustomEvents = {}> = {
+    [K in keyof ClientAllProviderEvents<CustomEvents> & string]: {
+        provider: K;
+        data: ClientAllProviderEvents<CustomEvents>[K];
+    };
+}[keyof ClientAllProviderEvents<CustomEvents> & string];
+type ClientEventTuple<CustomEvents = {}> = {
+    [K in keyof ClientAllProviderEvents<CustomEvents> & string]: [
+        provider: K,
+        event: ClientAllProviderEvents<CustomEvents>[K]
+    ];
+}[keyof ClientAllProviderEvents<CustomEvents> & string];
+
+declare namespace StreamElementsEvents {
+    namespace Tip {
+        type Data = {
+            listener: 'tip-latest';
+            event: Event;
+        };
+        type Event = {
+            amount: number;
+            avatar: string;
+            name: string;
+            displayName: string;
+            providerId: string;
+            _id: string;
+            sessionTop: boolean;
+            type: 'tip';
+            originalEventName: 'tip-latest';
+        };
+    }
+    namespace KVStore {
+        type Data = {
+            listener: 'kvstore:update';
+            event: Event;
+        };
+        type Event = {
+            data: {
+                key: `customWidget.${string}`;
+                value: string | number | boolean | Record<string, any>;
+            };
+        };
+    }
+    namespace BotCounter {
+        type Data = {
+            listener: 'bot:counter';
+            event: Event;
+        };
+        type Event = {
+            counter: string;
+            value: number;
+        };
+    }
+    namespace AlertService {
+        type Data = {
+            listener: 'alertService:toggleSound';
+            event: Event;
+        };
+        type Event = {
+            muted: boolean;
+        };
+    }
+    namespace EventSkip {
+        type Data = {
+            listener: 'event:skip';
+            event: Event;
+        };
+        type Event = {};
+    }
+    namespace EventTest {
+        export type Data = {
+            listener: 'event:test';
+            event: Event;
+        };
+        export type Event = widgetButton | emulatedEvents<EventType> | Session;
+        type items = {
+            name: string;
+            price: number;
+            quantity: number;
+        };
+        type widgetButton = {
+            listener: 'widget-button';
+            field: string;
+            value: string | number | boolean;
+        };
+        type EventType = 'follower' | 'subscriber' | 'tip' | 'cheer' | 'raid';
+        type EventTier = 'prime' | '1000' | '2000' | '3000';
+        type emulatedEvents<T extends EventType> = {
+            listener: `${T}-latest`;
+            event: {
+                type: T;
+                name: string;
+                amount: number;
+                count: number;
+                message?: string;
+                gifted?: boolean;
+                bulkGifted?: boolean;
+                sender?: string;
+                subExtension?: boolean;
+                items: items[];
+                tier: EventTier;
+                month: string;
+                isTest: true;
+            };
+        };
+        type Session = SessionCount | SessionTotal | SessionTop | SessionGoal | SessionRecent | SessionPoints;
+        type SessionCount = {
+            listener: `${EventType}-count`;
+            event: {
+                type: EventType;
+                name: string;
+                count: number;
+                items: items[];
+                tier: EventTier;
+                month: string;
+                isTest: true;
+            };
+        };
+        type SessionTotal = {
+            listener: `${EventType}-total`;
+            event: {
+                type: EventType;
+                name: string;
+                amount: number;
+                count: number;
+                items: items[];
+                tier: EventTier;
+                month: string;
+                isTest: true;
+            };
+        };
+        type SessionTop = {
+            listener: `${EventType}-top`;
+            event: {
+                type: EventType;
+                name: string;
+                amount: number;
+                count: number;
+                items: items[];
+                tier: EventTier;
+                month: string;
+                isTest: true;
+            };
+        };
+        type SessionGoal = {
+            listener: `${EventType}-goal`;
+            event: {
+                type: EventType;
+                name: string;
+                amount: number;
+                count: number;
+                items: items[];
+                tier: EventTier;
+                month: string;
+                isTest: true;
+            };
+        };
+        type SessionRecent = {
+            listener: `${EventType}-recent`;
+            event: {
+                event: SessionRecentEvent[];
+            };
+        };
+        type SessionRecentEvent = {
+            type: EventType;
+            name: string;
+            amount: number;
+            count: number;
+            tier: EventTier;
+            isTest: true;
+        };
+        type SessionPoints = {
+            listener: `${EventType}-points`;
+            event: {
+                type: EventType;
+                name: string;
+                amount: number;
+                count: number;
+                items: items[];
+                tier: EventTier;
+                month: string;
+                isTest: true;
+            };
+        };
+        export {};
+    }
+    interface BaseEvent {
+        provider: Provider$1;
+        flagged: boolean;
+        channel: string;
+        createdAt: string;
+        _id: string;
+        expiresAt: string;
+        updatedAt: string;
+        activityId: string;
+        sessionEventsCount: number;
+        isMock?: boolean;
+    }
+    namespace Event {
+        type Data = {
+            listener: 'event';
+            event: Event;
+        };
+        type Event = Tip;
+        interface Tip extends BaseEvent {
+            type: 'tip';
+            data: {
+                amount: string;
+                currency: string;
+                username: string;
+                message: string;
+                avatar: string;
+            };
+        }
+    }
+}
+
+type JSONPrimitive = string | number | boolean | null;
+type JSONSerializable = JSONPrimitive | JSONSerializable[] | {
+    [k: string]: JSONSerializable | undefined;
+};
+type JSONObject = {
+    [key: string]: JSONSerializable | undefined;
+};
+
+type RequireAtLeastOne<T, Keys extends keyof T = keyof T> = Pick<T, Exclude<keyof T, Keys>> & {
+    [K in Keys]-?: Required<Pick<T, K>> & Partial<Pick<T, Exclude<Keys, K>>>;
+}[Keys];
+
 interface CommandOptions {
     prefix?: string;
     name: string;
@@ -1788,19 +1800,13 @@ declare class EventProvider<EventMap extends Record<string, any[]> = Record<stri
     removeAllListeners<K extends keyof EventMap>(eventName: K): this;
 }
 
-type JSONPrimitive = string | number | boolean | null;
-type JSONSerializable = JSONPrimitive | JSONSerializable[] | {
-    [k: string]: JSONSerializable | undefined;
-};
-type JSONObject = {
-    [key: string]: JSONSerializable | undefined;
-};
-
 type UseStorageEvents<T> = {
-    load: [T | null];
-    update: [T];
+    load: [T];
+    update: [T, from: string];
+    save: [T];
 };
 type UseStorageOptions<T> = {
+    /** The unique identifier for the storage instance. */
     id?: string;
     data: T;
 };
@@ -1809,6 +1815,7 @@ declare class useStorage<T extends JSONObject> extends EventProvider<UseStorageE
     /** The unique identifier for the storage instance. */
     id: string;
     loaded: boolean;
+    private initial;
     data: T;
     constructor(options: UseStorageOptions<T>);
     /**
@@ -1831,14 +1838,6 @@ declare class useStorage<T extends JSONObject> extends EventProvider<UseStorageE
      * Clears all data from the storage.
      */
     clear(): void;
-    /**
-     * Sets a value in the storage at the specified path.
-     * @param obj The object to set the value in
-     * @param path The path to set the value at
-     * @param value The value to set
-     * @returns The updated object
-     */
-    static setByPath<P extends string, T extends object>(obj: T, path: P, value: PathValue<T, P>): void;
     on<K extends keyof UseStorageEvents<T>>(eventName: K, callback: (this: useStorage<T>, ...args: UseStorageEvents<T>[K]) => void): this;
 }
 
@@ -1928,10 +1927,6 @@ declare class Client<CustomEvents = {}> extends EventProvider<ClientMapEvents<Cu
     on<K extends keyof ClientMapEvents<CustomEvents>>(eventName: K, callback: (this: Client<CustomEvents>, ...args: ClientMapEvents<CustomEvents>[K]) => void): this;
 }
 
-type RequireAtLeastOne<T, Keys extends keyof T = keyof T> = Pick<T, Exclude<keyof T, Keys>> & {
-    [K in Keys]-?: Required<Pick<T, K>> & Partial<Pick<T, Exclude<Keys, K>>>;
-}[Keys];
-
 interface ButtonOptions {
     field: string | ((field: string, value: string | boolean | number) => boolean);
     template?: string;
@@ -2508,6 +2503,36 @@ declare class ObjectHelper {
      * @returns An array of keys from the object, typed as an array of strings.
      */
     keys<K extends string, V>(obj: Record<K, V>): K[];
+    /**
+     * Updates a value in a nested object at the specified path, with an option to create missing intermediate objects.
+     * @param obj - The target object to update.
+     * @param path - The path to the property being updated.
+     * @param value - The value to set at the specified path.
+     * @param createMissing - Whether to create missing intermediate objects along the path if they don't exist.
+     * @returns The updated object with the new value set at the specified path.
+     * @example
+     * ```javascript
+     * const obj1 = { a: { b: 1 }, c: 2 };
+     * updateViaPath(obj1, 'a.d', 9999, false);
+     * console.log(obj1);
+     * // Output: { a: { b: 1, d: 9999 }, c: 2 }
+     *
+     * const obj2 = { a: { b: 1 }, c: 2 };
+     * updateViaPath(obj2, 'a.e.f', 8888, true);
+     * console.log(obj2);
+     * // Output: { a: { b: 1, e: { f: 8888 } }, c: 2 }
+     * ```
+     * @returns The updated object with the new value set at the specified path.
+     */
+    updateViaPath<P extends string, T extends object>(obj: T, path: P, value: PathValue<T, P>, createMissing?: boolean): T;
+    /**
+     * Compares two values for differences, with an option to use JSON stringification for comparison.
+     * @param a - The first value to compare.
+     * @param b - The second value to compare.
+     * @param method - The method to use for comparison, either 'json' for JSON stringification or 'default' for a recursive comparison.
+     * @returns A boolean indicating whether the two values are different based on the specified comparison method.
+     */
+    isDiff(a: any, b: any, method?: 'json' | 'default'): boolean;
 }
 
 type BadgeOptions = Twitch.tags[] | Twitch.tags | `${Twitch.tags}/${string}` | `${Twitch.tags}/${string}`[];
@@ -3036,7 +3061,7 @@ declare class UtilsHelper {
         userId: string;
         name: string;
         broadcasterId?: string;
-    }, session: StreamElements.Session.Data, checkWithAPI?: boolean): Promise<3 | 1 | 2>;
+    }, session: StreamElements.Session.Data, checkWithAPI?: boolean): Promise<1 | 2 | 3>;
     /**
      * Identifies a user based on the received event and session data, returning their ID, name, role, badges, and top status.
      * @param receivedEvent - The event received from the provider (Twitch or YouTube) containing user information.
@@ -3577,7 +3602,7 @@ interface FakeUserPoolOptions {
     };
 }
 type FakeUserPoolEvents = {
-    'warn': [warning: Error];
+    warn: [warning: Error];
 };
 declare class FakeUserPool extends EventProvider<FakeUserPoolEvents> {
     readonly users: FakeUser[];