@tixyel/streamelements 6.0.3 → 6.2.0

package/dist/index.d.ts

@@ -1740,15 +1740,12 @@ type UseStorageOptions<T> = {
     data: T;
 };
 declare class useStorage<T extends JSONObject> extends EventProvider<UseStorageEvents<T>> {
-    /**
-     * The unique identifier for the storage instance.
-     */
+    private SE_API;
+    /** The unique identifier for the storage instance. */
     id: string;
     loaded: boolean;
     data: T;
     constructor(options: UseStorageOptions<T>);
-    SE_API: StreamElements.SE_API | null;
-    private start;
     /**
      * Saves the current data to storage.
      * @param data Data to save (defaults to current)
@@ -2041,6 +2038,7 @@ declare namespace Helper {
          * @param amount - Number to balance
          * @param min - Minimum value
          * @param max - Maximum value
+         * @param decimals - Number of decimal places to round to (default is 0)
          * @returns - Balanced number
          * @example
          * ```javascript
@@ -2048,7 +2046,7 @@ declare namespace Helper {
          * console.log(balancedValue); // 100
          * ```
          */
-        function balance(amount: number, min?: number, max?: number): number;
+        function balance(amount: number, min?: number, max?: number, decimals?: number): number;
         /**
          * Rounds a number to a specified number of decimal places
          * @param value - Number to round
@@ -2056,11 +2054,27 @@ declare namespace Helper {
          * @returns Rounded number
          * @example
          * ```javascript
-         * const roundedValue = Simulation.number.float(3.14159, 3);
+         * const roundedValue = Simulation.number.round(3.14159, 3);
          * console.log(roundedValue); // 3.142
          * ```
          */
         function round(value: number, decimals?: number): number;
+        /**
+         * Generate random number
+         * @param min - Minimum value
+         * @param max - Maximum value
+         * @param float - Number of decimal places (0 for integer)
+         * @returns - Random number
+         * @example
+         * ```javascript
+         * const intNumber = number.random(1, 10);
+         * console.log(intNumber); // e.g. 7
+         *
+         * const floatNumber = number.random(1, 10, 2);
+         * console.log(floatNumber); // e.g. 3.14
+         * ```
+         */
+        const random: typeof Helper.random.number;
     }
     namespace utils {
         /**
@@ -2074,19 +2088,19 @@ declare namespace Helper {
          * @param obj - The object to get entries from.
          * @returns An array of key-value pairs from the object.
          */
-        function typedEntries<K extends string, V>(obj: Record<K, V> | Array<V>): [K, V][];
+        const typedEntries: typeof object.entries;
         /**
          * Returns typed values of an object.
          * @param obj - The object to get values from.
          * @returns An array of values from the object.
          */
-        function typedValues<K extends string, V>(obj: Record<K, V> | Array<V>): V[];
+        const typedValues: typeof object.values;
         /**
          * Returns typed keys of an object.
          * @param obj - The object to get keys from.
          * @returns An array of keys from the object.
          */
-        function typedKeys<K extends string, V>(obj: Record<K, V> | Array<V>): K[];
+        const typedKeys: typeof object.keys;
         /**
          * Selects an item based on weighted probabilities.
          * @param items - An object where keys are items and values are their weights.
@@ -2222,6 +2236,24 @@ declare namespace Helper {
          * ```
          */
         function flatten(obj: Record<string, any>, stringify?: boolean, prefix?: string): Record<string, typeof stringify extends true ? string : string | number | boolean>;
+        /**
+         * Returns the entries of an object as an array of key-value pairs, with proper typing.
+         * @param obj - The object to retrieve entries from.
+         * @returns An array of key-value pairs from the object, typed as an array of tuples with key and value types.
+         */
+        function entries<K extends string, V>(obj: Record<K, V>): [K, V][];
+        /**
+         * Returns the values of an object as an array, with proper typing.
+         * @param obj - The object to retrieve values from.
+         * @returns An array of values from the object, typed as an array of the value type.
+         */
+        function values<K extends string, V>(obj: Record<K, V>): V[];
+        /**
+         * Returns the keys of an object as an array of strings, with proper typing.
+         * @param obj - The object to retrieve keys from.
+         * @returns An array of keys from the object, typed as an array of strings.
+         */
+        function keys<K extends string, V>(obj: Record<K, V>): K[];
     }
     namespace message {
         type BadgeOptions = Twitch.roles[] | Twitch.roles | `${Twitch.roles}, ${Twitch.roles}` | `${Twitch.roles}, ${Twitch.roles}, ${Twitch.roles}`;
@@ -2563,6 +2595,24 @@ declare namespace Helper {
          */
         function uuid(): string;
     }
+    namespace fn {
+        /**
+         * Apply function with given thisArg and arguments
+         * @param fn - Function to apply
+         * @param thisArg - Value to use as this when calling fn
+         * @param args - Arguments to pass to fn
+         * @returns Result of calling fn with thisArg and args
+         */
+        function apply<TThis, TArgs extends unknown[], TReturn>(fn: (this: TThis, ...args: TArgs) => TReturn, thisArg: TThis, args: TArgs): TReturn;
+        /**
+         * Call function with given thisArg and arguments
+         * @param fn - Function to call
+         * @param thisArg - Value to use as this when calling fn
+         * @param args - Arguments to pass to fn
+         * @returns Result of calling fn with thisArg and args
+         */
+        function call<TThis, TArgs extends unknown[], TReturn>(fn: (this: TThis, ...args: TArgs) => TReturn, thisArg: TThis, ...args: TArgs): TReturn;
+    }
 }
 
 declare namespace Local {
@@ -2829,6 +2879,58 @@ declare namespace Data {
     }[];
 }
 
+type MessageMap = Record<string, any>;
+type MessageTuple<T extends MessageMap> = {
+    [K in keyof T]: [key: K, data: T[K]];
+}[keyof T];
+type BaseEvents<T extends MessageMap> = {
+    load: [];
+    message: MessageTuple<T>;
+};
+type UseCommsOptions = {
+    id?: string;
+};
+type UseCommItem<T extends MessageMap> = {
+    nonce: string;
+    key: keyof T;
+    value: T[keyof T];
+    timestamp: string;
+};
+/**
+ * A module for handling communications between different widgets inside streamelements.
+ * @example
+ * ```ts
+ * type CommsMessages = {
+ *   hello: { loaded: boolean };
+ *   update: { value: number };
+ *   reload: {};
+ *   tags: string[];
+ * }
+ *
+ * const comms = new useComms<CommsMessages>();
+ *
+ * comms.on('message', (message, data) => {
+ *   switch (message) {
+ *     case 'hello': {}
+ *     case 'update': {}
+ *     case 'reload': {}
+ *     case 'tags': {}
+ *   }
+ * })
+ * ```
+ */
+declare class useComms<T extends MessageMap> extends EventProvider<BaseEvents<T>> {
+    private SE_API;
+    id: string;
+    loaded: boolean;
+    private history;
+    private detected;
+    constructor(options?: UseCommsOptions);
+    send<K extends keyof T>(key: K, data: T[K]): Promise<void>;
+    update(history: Array<UseCommItem<T>>): void;
+    on<K extends keyof BaseEvents<T>>(eventName: K, callback: (this: useComms<T>, ...args: BaseEvents<T>[K]) => void): this;
+}
+
 declare const main: {
     SeAPI: Promise<StreamElements.SE_API>;
     Client: typeof Client;
@@ -2841,6 +2943,7 @@ declare const main: {
         useStorage: typeof useStorage;
         useQueue: typeof useQueue;
         useLogger: typeof useLogger;
+        useComms: typeof useComms;
     };
     actions: {
         Button: typeof Button;
@@ -2851,6 +2954,7 @@ declare const main: {
     };
     data: {
         usedStorages: useStorage<any>[];
+        usedComms: useComms<any>[];
     };
     pronouns: {
         Alejo: typeof Alejo;