@tixyel/streamelements 4.5.4 → 4.5.6

package/dist/index.d.ts

@@ -1826,7 +1826,7 @@ declare class useQueue<T> extends EventProvider<QueueEvents<T>> {
 }
 
 declare namespace Simulation {
-    export const data: {
+    const data: {
         names: string[];
         messages: string[];
         tiers: string[];
@@ -1857,246 +1857,45 @@ declare namespace Simulation {
         pronouns: typeof Alejo.Pronouns.map;
         css_color_names: string[];
     };
-    export const color: {
-        /**
-         * Generate opacity hex value
-         * @param opacity - Opacity value from 0 to 100
-         * @param color - Hex color code
-         * @returns - Hex color code with opacity
-         */
+    const color: {
         opacity(opacity?: number, color?: string): string;
-        /**
-         * Extract color and opacity from hex code
-         * @param hex - Hex color code
-         * @returns - Object with color and opacity
-         */
         extract(hex: string): {
             color: string;
             opacity: number;
         };
         validate(str: string): false | "hex" | "rgb" | "rgba" | "hsl" | "hsla" | "css-color-name";
-        /**
-         * Convert color to different format
-         * @param str - Color string to convert (e.g. "#FF5733", "rgb(255, 87, 51)")
-         * @param format - Target format
-         * @returns - Converted color string
-         * @example
-         * ```javascript
-         * const hexColor = Simulation.color.convert("rgb(255, 87, 51)", "hex"); // "#FF5733"
-         * const rgbColor = Simulation.color.convert("#FF5733", "rgb"); // "rgb(255, 87, 51)"
-         * const hslColor = Simulation.color.convert("#FF5733", "hsl"); // "hsl(14, 100%, 60%)"
-         * const colorName = Simulation.color.convert("#FF5733", "css-color-name"); // "orangered"
-         * ```
-         */
         convert(str: string, format: "hex" | "rgb" | "rgba" | "hsl" | "hsla" | "css-color-name"): string | null;
+        random: (type?: "hex" | "hexa" | "rgb" | "rgba" | "hsl" | "hsla" | "css-color-name") => string;
     };
-    export const rand: {
-        /**
-         * Generate random color
-         * @param type - Color format
-         * @returns - Random color in specified format
-         * @example
-         * ```javascript
-         * const hexColor = Simulation.rand.color('hex');
-         * console.log(hexColor); // e.g. #3e92cc
-         *
-         * const rgbColor = Simulation.rand.color('rgb');
-         * console.log(rgbColor); // e.g. rgb(62, 146, 204)
-         * ```
-         */
+    const rand: {
         color(type?: "hex" | "hexa" | "rgb" | "rgba" | "hsl" | "hsla" | "css-color-name"): string;
-        /**
-         * 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 = Simulation.rand.number(1, 10);
-         * console.log(intNumber); // e.g. 7
-         *
-         * const floatNumber = Simulation.rand.number(1, 10, 2);
-         * console.log(floatNumber); // e.g. 3.14
-         * ```
-         */
         number(min: number, max: number, float?: number): number;
-        /**
-         * Generate random boolean
-         * @param threshold - Threshold between 0 and 1
-         * @returns - Random boolean
-         * @example
-         * ```javascript
-         * const boolValue = Simulation.rand.boolean(0.7);
-         * console.log(boolValue); // e.g. true (70% chance)
-         * ```
-         */
         boolean(threshold?: number): boolean;
-        /**
-         * Generate random string
-         * @param length - Length of the string
-         * @param chars - Characters to use
-         * @returns - Random string
-         * @example
-         * ```javascript
-         * const randString = Simulation.rand.string(10);
-         * console.log(randString); // e.g. "aZ3bT9xYqP"
-         * ```
-         */
         string(length: number, chars?: string): string;
-        /**
-         * Pick random element from array
-         * @param arr - Array to pick from
-         * @returns - Random element and its index
-         * @example
-         * ```javascript
-         * const [element, index] = Simulation.rand.array(['apple', 'banana', 'cherry']);
-         * console.log(element, index); // e.g. "banana", 1
-         * ```
-         */
         array<T>(arr: T[]): [value: T, index: number];
-        /**
-         * Generate random date
-         * @param start - Start date
-         * @param end - End date
-         * @returns - Random date between start and end
-         * @example
-         * ```javascript
-         * const randDate = Simulation.rand.date(new Date(2020, 0, 1), new Date());
-         * console.log(randDate); // e.g. 2022-05-15T10:30:00.000Z
-         * ```
-         */
         date(start?: Date, end?: Date): Date;
-        /**
-         * Generate ISO date string offset by days
-         * @param daysAgo - Number of days to go back
-         * @returns - ISO date string
-         * @example
-         * ```javascript
-         * const isoDate = Simulation.rand.daysOffset(7);
-         * console.log(isoDate); // e.g. "2024-06-10T14:23:45.678Z"
-         *
-         * const isoDate30 = Simulation.rand.daysOffset(30);
-         * console.log(isoDate30); // e.g. "2024-05-18T09:15:30.123Z"
-         * ```
-         */
         daysOffset(daysAgo: number): string;
-        /**
-         * Generate UUID v4
-         * @returns - UUID string
-         * @example
-         * ```javascript
-         * const uuid = Simulation.rand.uuid();
-         * console.log(uuid); // e.g. "3b12f1df-5232-4e3a-9a0c-3f9f1b1b1b1b"
-         * ```
-         */
         uuid(): string;
     };
-    type Modifier = (value: string, param: string | null | undefined, values: {
-        amount?: number;
-        count?: number;
-    }) => string;
-    export const string: {
-        /**
-         * Replaces occurrences in a string based on a pattern with the result of an asynchronous callback function.
-         * @param string - The input string to perform replacements on.
-         * @param pattern - The pattern to match in the string (can be a string or a regular expression).
-         * @param callback - An asynchronous callback function that takes the matched substring and any captured groups as arguments and returns the replacement string.
-         * @returns A promise that resolves to the modified string with replacements applied.
-         * @example
-         * ```javascript
-         * const result = await Simulation.string.replace("Hello World", /World/, async (match) => {
-         *   return await fetchSomeData(match); // Assume this function fetches data asynchronously
-         * });
-         * console.log(result); // Output will depend on the fetched data
-         * ```
-         */
+    const string: {
         replace(string: string, pattern: string, callback: (match: string, ...groups: string[]) => Promise<string> | string): Promise<string>;
-        /**
-         * Capitalizes the first letter of a given string.
-         * @param string - The input string to be capitalized.
-         * @returns The capitalized string.
-         * @example
-         * ```javascript
-         * const result = Simulation.string.capitalize("hello world");
-         * console.log(result); // Output: "Hello world"
-         * ```
-         */
         capitalize(string: string): string;
-        /**
-         * Composes a template string by replacing placeholders with corresponding values and applying optional modifiers.
-         * @param template - The template string containing placeholders in the format {key} and optional modifiers in the format [MODIFIER:param=value].
-         * @param values - An object containing key-value pairs to replace the placeholders in the template.
-         * @param options - Optional settings for the composition process.
-         * @returns The composed string with placeholders replaced and modifiers applied.
-         * @example
-         * ```javascript
-         * const template = "Hello, {username}! You have {amount} [UPPERCASE=messages] and your name is [CAPITALIZE=name].";
-         * const values = { username: "john_doe", amount: 5, name: "john" };
-         * const result = Simulation.string.compose(template, values);
-         * console.log(result); // Output: "Hello, john_doe! You have 5 MESSAGES and your name is John."
-         * ```
-         */
         compose(template: string, values?: Record<string, any>, options?: {
             method?: "loop" | "index";
             html?: boolean;
-            modifiers?: Record<string, Modifier>;
+            modifiers?: Record<string, (value: string, param: string | null | undefined, values: {
+                amount?: number;
+                count?: number;
+            }) => string>;
             aliases?: Record<string, string[]>;
         }): string;
     };
-    export const number: {
-        /**
-         * Translate number to words
-         * @param num - Number to translate
-         * @param type - Translation type
-         * @returns - Number in words
-         * @example
-         * ```javascript
-         * const cardinal = Simulation.number.translate(42, 'cardinal');
-         * console.log(cardinal); // "forty-two"
-         * ```
-         */
+    const number: {
         translate(num: number, type?: "cardinal" | "ordinal" | "suffix"): string;
-        /**
-         * Balances a number within a specified range
-         * @param amount - Number to balance
-         * @param min - Minimum value
-         * @param max - Maximum value
-         * @returns - Balanced number
-         * @example
-         * ```javascript
-         * const balancedValue = Simulation.number.balance(150, 0, 100);
-         * console.log(balancedValue); // 100
-         * ```
-         */
         balance(amount: number, min?: number, max?: number): number;
     };
-    export const element: {
-        /**
-         * Merges outer span styles with inner span styles in the provided HTML string.
-         * @param outerStyle - The style string to be applied to the outer span.
-         * @param innerHTML - The inner HTML string which may contain a span with its own styles.
-         * @returns A new HTML string with merged styles applied to a single span.
-         * @example
-         * ```javascript
-         * const result = Simulation.element.mergeSpanStyles("color: red; font-weight: bold;", '<span style="font-size: 14px;">Hello World</span>');
-         * console.log(result); // Output: '<span style="font-size: 14px; color: red; font-weight: bold;">Hello World</span>'
-         * ```
-         */
-        mergeSpanStyles(outerStyle: string, innerHTML: string): string;
-        /**
-         * Scales an HTML element to fit within its parent element based on specified minimum and maximum scale factors.
-         * @param element - The HTML element to be scaled.
-         * @param min - Minimum scale factor (default is 0).
-         * @param max - Maximum scale factor (default is 1).
-         * @param options - Optional settings for scaling.
-         * @returns - An object containing the new width, height, and scale factor, or void if not applied.
-         * @example
-         * ```javascript
-         * const element = document.getElementById('myElement');
-         * Simulation.element.scale(element, 0.5, 1, { return: false });
-         * ```
-         */
+    const element: {
+        mergeSpanStyles(outerStyle: string, innerHTML: string, className?: string): string;
         scale(element: HTMLElement, min?: number, max?: number, options?: {
             return: boolean;
             parent: HTMLElement;
@@ -2106,37 +1905,12 @@ declare namespace Simulation {
             height: number;
             scale: number;
         } | void;
-        /**
-         * Splits the text content of an HTML string into individual characters wrapped in span elements with a data-index attribute.
-         * @param htmlString - The input HTML string to be processed.
-         * @param startIndex - The starting index for the data-index attribute (default is 0).
-         * @returns - A new HTML string with each character wrapped in a span element.
-         * @example
-         * ```javascript
-         * const result = Simulation.element.splitTextToChars("<p>Hello</p>", 0);
-         * console.log(result);
-         * // Output: '<p><span class="char" data-index="0">H</span><span class="char" data-index="1">e</span><span class="char" data-index="2">l</span><span class="char" data-index="3">l</span><span class="char" data-index="4">o</span></p>'
-         * ```
-         */
         splitTextToChars(htmlString: string, startIndex?: number): string;
     };
-    export const object: {
-        /**
-         * Flattens a nested object into a single-level object with dot-separated keys.
-         * @param obj - The nested object to be flattened.
-         * @param prefix  - The prefix to be added to each key (used for recursion).
-         * @returns A flattened object with dot-separated keys.
-         * @example
-         * ```javascript
-         * const nestedObj = { a: { b: 1, c: { d: 2 } }, e: [3, 4] };
-         * const flatObj = Simulation.object.flatten(nestedObj);
-         * console.log(flatObj);
-         * // Output: { 'a.b': '1', 'a.c.d': '2', 'e:0': '3', 'e:1': '4' }
-         * ```
-         */
+    const object: {
         flatten(obj: Record<string, any>, prefix?: string): Record<string, string>;
     };
-    export const generate: {
+    const generate: {
         session: {
             types: Record<string, StreamElements.Session.Config.Any>;
             available(): StreamElements.Session.Config.Available.Data;
@@ -2175,7 +1949,7 @@ 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 var queue: useQueue<{
+    var queue: useQueue<{
         listener: 'onEventReceived';
         data: StreamElements.Event.onEventReceived;
         session?: boolean;
@@ -2186,7 +1960,7 @@ declare namespace Simulation {
         listener: 'onSessionUpdate';
         data: StreamElements.Event.onSessionUpdate;
     }> | undefined;
-    export const emulate: {
+    const emulate: {
         twitch: {
             message(data?: Partial<{
                 name: string;
@@ -2276,16 +2050,15 @@ declare namespace Simulation {
      * @param ms - The number of milliseconds to delay.
      * @returns A Promise that resolves after the specified delay.
      */
-    export function delay(ms: number): Promise<void>;
+    function delay(ms: number): Promise<void>;
     /**
      * Returns typed entries of an object.
      * @param obj - The object to get entries from.
      * @returns - An array of key-value pairs from the object.
      */
-    export function typedEntries<K extends string, V>(obj: Record<K, V>): [K, V][];
-    export function probability<K extends string, V extends number>(items: Record<K, V>): K | undefined;
-    export function start(fieldsFile?: string[], dataFiles?: string[], session?: StreamElements.Session.Data): Promise<void>;
-    export {};
+    function typedEntries<K extends string, V>(obj: Record<K, V>): [K, V][];
+    function probability<K extends string, V extends number>(items: Record<K, V>): K | undefined;
+    function start(fieldsFile?: string[], dataFiles?: string[], session?: StreamElements.Session.Data): Promise<void>;
 }
 
 type JSONPrimitive = string | number | boolean | null;