@tixyel/streamelements 4.1.0 → 4.2.0

package/dist/index.d.ts

@@ -764,10 +764,12 @@ declare namespace TwitchEvents {
             event: Event;
         };
         export type Event = common & (normal | gift | community | spam);
+        export type SubscriberTier = 'prime' | '1000' | '2000' | '3000';
         type common = {
             amount: number;
             name: string;
             displayName: string;
+            tier: SubscriberTier;
             message?: string;
             providerId?: string;
             avatar?: string;
@@ -869,7 +871,7 @@ declare namespace TwitchEvents {
             username: string;
             displayName: string;
             providerId: string;
-            tier: 'prime' | '1000' | '2000' | '3000';
+            tier: Subscriber.SubscriberTier;
             quantity: 0;
             avatar: string;
         };
@@ -879,7 +881,7 @@ declare namespace TwitchEvents {
             displayName: string;
             providerId: string;
             message: string;
-            tier: 'prime' | '1000' | '2000' | '3000';
+            tier: Subscriber.SubscriberTier;
             streak: number;
             quantity: number;
             avatar: string;
@@ -890,7 +892,7 @@ declare namespace TwitchEvents {
             displayName: string;
             providerId: string;
             message: string;
-            tier: 'prime' | '1000' | '2000' | '3000';
+            tier: Subscriber.SubscriberTier;
             sender: string;
             gifted: true;
             quantity: 0;
@@ -902,7 +904,7 @@ declare namespace TwitchEvents {
             displayName: string;
             providerId: string;
             message: string;
-            tier: 'prime' | '1000' | '2000' | '3000';
+            tier: Subscriber.SubscriberTier;
             sender: string;
             gifted: true;
             quantity: 0;
@@ -1017,6 +1019,7 @@ declare namespace StreamElements {
             }
             namespace Twitch {
                 type Events = TwitchEvents.Raid.Data | TwitchEvents.Event.Data | TwitchEvents.Cheer.Data | TwitchEvents.Message.Data | TwitchEvents.Follower.Data | TwitchEvents.Subscriber.Data | TwitchEvents.DeleteMessage.Data | TwitchEvents.DeleteMessages.Data;
+                type SubscriberTier = TwitchEvents.Subscriber.SubscriberTier;
                 type Raid = TwitchEvents.Raid.Data;
                 type Event = TwitchEvents.Event.Data;
                 type Cheer = TwitchEvents.Cheer.Data;
@@ -1237,27 +1240,27 @@ declare namespace StreamElements {
                 name: string;
                 amount: number;
             };
-            'cheer-weekly-top-donation': {
+            'cheer-session-top-donator': {
                 name: string;
                 amount: number;
             };
-            'cheer-monthly-top-donation': {
+            'cheer-weekly-top-donation': {
                 name: string;
                 amount: number;
             };
-            'cheer-alltime-top-donation': {
+            'cheer-weekly-top-donator': {
                 name: string;
                 amount: number;
             };
-            'cheer-session-top-donator': {
+            'cheer-monthly-top-donation': {
                 name: string;
                 amount: number;
             };
-            'cheer-weekly-top-donator': {
+            'cheer-monthly-top-donator': {
                 name: string;
                 amount: number;
             };
-            'cheer-monthly-top-donator': {
+            'cheer-alltime-top-donation': {
                 name: string;
                 amount: number;
             };
@@ -1603,6 +1606,70 @@ declare namespace Alejo {
     function get(username: string): Promise<Pronouns.name | undefined>;
 }
 
+type QueueEvents<T> = {
+    load: [];
+    cancel: [];
+    update: [queue: QueueItem<T>[], priorityQueue: QueueItem<T>[], history: QueueItem<T>[], timeouts: Array<ReturnType<typeof setTimeout>>];
+    process: [item: QueueItem<T>, queue: useQueue<T>];
+};
+type QueueProps = {
+    isoDate: string;
+    isLoop: boolean;
+    isPriority: boolean;
+    isImmediate: boolean;
+};
+type QueueItem<T> = {
+    value: T;
+} & QueueProps;
+type QueueProcessor<T> = (item: T, queue: useQueue<T>) => Promise<any>;
+type QueueDuration = number | boolean | undefined;
+interface QueueOptions<T> {
+    /**
+     * Duration between processing each item in milliseconds. Set to `0` or `false` for immediate processing.
+     */
+    duration: QueueDuration | 'client';
+    /**
+     * Function to process each item in the queue.
+     */
+    processor: QueueProcessor<T>;
+}
+/**
+ * A utility class to manage a queue of items with support for priority, looping, and immediate processing.
+ * @template T - The type of items in the queue.
+ * @extends EventProvider<QueueEvents<T>>
+ * @example
+ * ```javascript
+ * const myQueue = new useQueue({
+ *   duration: 1000,
+ *   processor: async (item) => {
+ *    console.log('Processing item:', item);
+ *  },
+ * });
+ *
+ * myQueue.enqueue('Item 1');
+ * myQueue.enqueue('Item 2', { isPriority: true });
+ * ```
+ */
+declare class useQueue<T> extends EventProvider<QueueEvents<T>> {
+    queue: QueueItem<T>[];
+    priorityQueue: QueueItem<T>[];
+    history: QueueItem<T>[];
+    private timeouts;
+    running: boolean;
+    duration: QueueDuration;
+    private loaded;
+    processor: QueueProcessor<T>;
+    constructor(options: QueueOptions<T>);
+    enqueue(value: T, options?: Partial<QueueProps>): this;
+    private run;
+    private next;
+    resume(): this;
+    update(save: Partial<useQueue<T>>): this;
+    cancel(): void;
+    hasItems(): boolean;
+    on<K extends keyof QueueEvents<T>>(eventName: K, callback: (this: useQueue<T>, ...args: QueueEvents<T>[K]) => void): this;
+}
+
 declare namespace Simulation {
     export const data: {
         names: string[];
@@ -1934,7 +2001,7 @@ declare namespace Simulation {
              * @param session - The session data to be included in the event.
              * @returns A Promise that resolves to the simulated onSessionUpdate event data.
              */
-            onSessionUpdate(session?: StreamElements.Session.Data): Promise<StreamElements.Event.onSessionUpdate>;
+            onSessionUpdate(session?: StreamElements.Session.Data, update?: ClientEvents$1): Promise<StreamElements.Event.onSessionUpdate>;
             /**
              * Simulates the onEventReceived event for a widget.
              * @param provider - The provider of the event (default is 'random').
@@ -1953,6 +2020,17 @@ declare namespace Simulation {
             onEventReceived(provider?: Provider$1 | "random", type?: StreamElements.Event.onEventReceived["listener"] | "random" | "tip" | "cheer" | "follower" | "raid" | "subscriber", options?: Record<string, string | number | boolean>): Promise<StreamElements.Event.onEventReceived | null>;
         };
     };
+    export const Queue: useQueue<{
+        listener: "onEventReceived";
+        data: StreamElements.Event.onEventReceived;
+        session?: boolean;
+    } | {
+        listener: "onWidgetLoad";
+        data: StreamElements.Event.onWidgetLoad;
+    } | {
+        listener: "onSessionUpdate";
+        data: StreamElements.Event.onSessionUpdate;
+    }>;
     export const emulate: {
         twitch: {
             message(data?: Partial<{
@@ -2269,53 +2347,6 @@ declare class Command {
     static execute(received: CommandEvent): boolean;
 }
 
-type QueueEvents<T> = {
-    load: [];
-    cancel: [];
-    update: [queue: QueueItem<T>[], priorityQueue: QueueItem<T>[], history: QueueItem<T>[], timeouts: Array<ReturnType<typeof setTimeout>>];
-    process: [item: QueueItem<T>, queue: useQueue<T>];
-};
-type QueueProps = {
-    isoDate: string;
-    isLoop: boolean;
-    isPriority: boolean;
-    isImmediate: boolean;
-};
-type QueueItem<T> = {
-    value: T;
-} & QueueProps;
-type QueueProcessor<T> = (item: T, queue: useQueue<T>) => Promise<any>;
-type QueueDuration = number | boolean | undefined;
-interface QueueOptions<T> {
-    /**
-     * Duration between processing each item in milliseconds. Set to `0` or `false` for immediate processing.
-     */
-    duration: QueueDuration;
-    /**
-     * Function to process each item in the queue.
-     */
-    processor: QueueProcessor<T>;
-}
-declare class useQueue<T> extends EventProvider<QueueEvents<T>> {
-    queue: QueueItem<T>[];
-    priorityQueue: QueueItem<T>[];
-    history: QueueItem<T>[];
-    private timeouts;
-    running: boolean;
-    duration: QueueDuration;
-    private loaded;
-    processor: QueueProcessor<T>;
-    constructor(options: QueueOptions<T>);
-    enqueue(value: T, options?: Partial<QueueProps>): this;
-    private run;
-    private next;
-    resume(): this;
-    update(save: Partial<useQueue<T>>): this;
-    cancel(): void;
-    hasItems(): boolean;
-    on<K extends keyof QueueEvents<T>>(eventName: K, callback: (this: useQueue<T>, ...args: QueueEvents<T>[K]) => void): this;
-}
-
 interface Theme {
     color?: string;
     background?: string;