@tixyel/streamelements 6.0.0 → 6.0.2

package/dist/index.d.ts

@@ -1874,7 +1874,7 @@ interface CommandOptions {
     run: (this: Client, args: string[], event: CommandEvent) => void;
     test?: string;
     aliases?: string[];
-    permissions?: string[];
+    permissions?: string[] | boolean;
     admins?: string[];
 }
 type CommandEvent = {
@@ -1919,7 +1919,7 @@ type QueueProps = {
 type QueueItem<T> = {
     value: T;
 } & QueueProps;
-type QueueProcessor<T> = (item: T, queue: useQueue<T>) => Promise<any>;
+type QueueProcessor<T> = (this: useQueue<T>, item: T, queue: useQueue<T>) => Promise<any>;
 type QueueDuration = number | boolean | undefined;
 interface QueueOptions<T> {
     /**
@@ -1939,7 +1939,7 @@ interface QueueOptions<T> {
  * ```javascript
  * const myQueue = new useQueue({
  *   duration: 1000,
- *   processor: async (item) => {
+ *   processor: async function (item) {
  *    console.log('Processing item:', item);
  *  },
  * });
@@ -1958,12 +1958,59 @@ declare class useQueue<T> extends EventProvider<QueueEvents<T>> {
     private loaded;
     processor: QueueProcessor<T>;
     constructor(options: QueueOptions<T>);
+    /**
+     * Enqueue an item or multiple items into the queue with optional processing options.
+     * @param value - The item or items to be enqueued. Can be a single value of type T or an array of objects containing the value and options.
+     * @param options - Optional processing options for the item(s) being enqueued. Ignored if an array of items is provided, as each item can have its own options.
+     * @returns The instance of the queue for chaining.
+     * @example
+     * ```javascript
+     * myQueue.enqueue('Single Item', { isPriority: true });
+     * myQueue.enqueue([
+     *   { value: 'Item 1', options: { isPriority: true } },
+     *   { value: 'Item 2', options: { isLoop: true } }
+     * ]);
+     * ```
+     */
     enqueue(value: T, options?: Partial<QueueProps>): this;
+    enqueue(items: {
+        value: T;
+        options?: Partial<QueueProps>;
+    }[]): this;
     private run;
     private next;
+    /**
+     * Resume processing the queue if it is paused. If the queue is already running, it will be restarted, which can be useful if new items have been added or if you want to reset the processing timer.
+     * If the queue was empty before, it will start processing immediately.
+     * @returns - The instance of the queue for chaining.
+     * @example
+     * ```javascript
+     * myQueue.resume();
+     * ```
+     */
     resume(): this;
+    /**
+     * Update the queue's state with new values. This can be used to replace the current queue, priority queue, history, or timeouts with new data. If the queue is not currently running and there are items in the queue after the update, it will start processing immediately.
+     * @param save - An object containing the new state for the queue, priority queue, history, and timeouts. Each property is optional, and if not provided, the current state will be retained.
+     * @returns - The instance of the queue for chaining.
+     * @example
+     * ```javascript
+     * myQueue.update({
+     *   queue: newQueueItems,
+     *   priorityQueue: newPriorityItems,
+     *   history: newHistory,
+     * });
+     * ```
+     */
     update(save: Partial<useQueue<T>>): this;
+    /**
+     * Cancel all pending timeouts and stop the queue from processing further items. This will clear any scheduled processing and prevent any new items from being processed until `resume()` is called again. The current state of the queue, priority queue, and history will be retained, allowing you to resume processing later without losing any data.
+     */
     cancel(): void;
+    /**
+     * Check if there are any items in the queue or priority queue. This method returns `true` if there are items waiting to be processed in either the main queue or the priority queue, and `false` if both queues are empty.
+     * @returns - A boolean indicating whether there are items in the queue or priority queue.
+     */
     hasItems(): boolean;
     on<K extends keyof QueueEvents<T>>(eventName: K, callback: (this: useQueue<T>, ...args: QueueEvents<T>[K]) => void): this;
 }

package/dist/index.es.js

@@ -2057,7 +2057,7 @@ const wt = [
   "Szabolcs",
   "Hoda",
   "Naayf"
-], It = [
+], Tt = [
   {
     emojiId: "UCkszU2WH9gy1mb0dV-11UJg/flower-rainbow-heart-red",
     shortcuts: [":pride-flower-rainbow-heart:"],
@@ -5233,7 +5233,7 @@ const wt = [
 ];
 var D;
 ((h) => {
-  h.avatars = wt, h.badges = vt, h.css_color_names = lt, h.emotes = kt, h.items = Ct, h.messages = jt, h.names = xt, h.tiers = Ut, h.tts = Et, h.youtube_emotes = It;
+  h.avatars = wt, h.badges = vt, h.css_color_names = lt, h.emotes = kt, h.items = Ct, h.messages = jt, h.names = xt, h.tiers = Ut, h.tts = Et, h.youtube_emotes = Tt;
 })(D || (D = {}));
 var y;
 ((h) => {
@@ -5618,8 +5618,8 @@ var y;
       function A(r, u) {
         const w = r?.trim?.() ?? "";
         if (!w.length) return null;
-        const x = u[w], I = parseFloat(String(x !== void 0 ? x : w).replace(/\s/g, ""));
-        return isNaN(I) ? null : I;
+        const x = u[w], T = parseFloat(String(x !== void 0 ? x : w).replace(/\s/g, ""));
+        return isNaN(T) ? null : T;
       }
       function J(r, u, w) {
         const x = isNaN(Number(u)) ? 0 : Math.max(0, parseInt(String(u))), N = A(r, w);
@@ -5634,45 +5634,45 @@ var y;
         }
       }
       function U(r, u = /* @__PURE__ */ new Date()) {
-        const w = u.getTime() - r.getTime(), x = w >= 0, N = Math.abs(w), I = Math.floor(N / 1e3), T = Math.floor(I / 60), M = Math.floor(T / 60), E = Math.floor(M / 24), H = Math.floor(E / 30), _ = Math.floor(E / 365), Y = x ? "ago" : "from now";
-        return _ > 0 ? `${_}y ${Y}` : H > 0 ? `${H}mo ${Y}` : E > 0 ? `${E}d ${Y}` : M > 0 ? `${M}h ${Y}` : T > 0 ? `${T}m ${Y}` : `${Math.max(I, 0)}s ${Y}`;
+        const w = u.getTime() - r.getTime(), x = w >= 0, N = Math.abs(w), T = Math.floor(N / 1e3), I = Math.floor(T / 60), M = Math.floor(I / 60), E = Math.floor(M / 24), H = Math.floor(E / 30), _ = Math.floor(E / 365), Y = x ? "ago" : "from now";
+        return _ > 0 ? `${_}y ${Y}` : H > 0 ? `${H}mo ${Y}` : E > 0 ? `${E}d ${Y}` : M > 0 ? `${M}h ${Y}` : I > 0 ? `${I}m ${Y}` : `${Math.max(T, 0)}s ${Y}`;
       }
       function S(r, u, w) {
         const x = r?.trim?.() ?? "";
         if (!x.length) return r;
-        const N = w[x] ?? x, I = new Date(N);
-        if (isNaN(I.getTime())) return r;
-        const T = (u ?? "date").toString().toLowerCase();
+        const N = w[x] ?? x, T = new Date(N);
+        if (isNaN(T.getTime())) return r;
+        const I = (u ?? "date").toString().toLowerCase();
         try {
-          switch (T) {
+          switch (I) {
             case "time":
-              return I.toLocaleTimeString();
+              return T.toLocaleTimeString();
             case "datetime":
             case "full":
-              return I.toLocaleString();
+              return T.toLocaleString();
             case "relative":
             case "ago":
-              return U(I);
+              return U(T);
             case "iso":
-              return I.toISOString();
+              return T.toISOString();
             default:
-              return I.toLocaleDateString();
+              return T.toLocaleDateString();
           }
         } catch {
           return r;
         }
       }
       function L(r, u, w) {
-        const x = r ?? "", [N, I = N] = x.split("|", 2), T = u?.trim();
+        const x = r ?? "", [N, T = N] = x.split("|", 2), I = u?.trim();
         let M;
-        T && w[T] !== void 0 ? M = w[T] : M = w.amount ?? w.count;
+        I && w[I] !== void 0 ? M = w[I] : M = w.amount ?? w.count;
         const E = parseFloat(String(M));
-        return isNaN(E) ? N : Math.abs(E) !== 1 ? I : N;
+        return isNaN(E) ? N : Math.abs(E) !== 1 ? T : N;
       }
       function O(r, u, w) {
-        const x = u?.trim() ?? "", N = x && w[x] !== void 0 ? w[x] : "", I = String(N), T = (r ?? "").split("|").map((E) => E.trim()).filter((E) => E.length);
+        const x = u?.trim() ?? "", N = x && w[x] !== void 0 ? w[x] : "", T = String(N), I = (r ?? "").split("|").map((E) => E.trim()).filter((E) => E.length);
         let M;
-        for (const E of T) {
+        for (const E of I) {
           const H = E.indexOf(":");
           if (H === -1) continue;
           const _ = E.slice(0, H).trim(), Y = E.slice(H + 1);
@@ -5681,7 +5681,7 @@ var y;
               M = Y;
               continue;
             }
-            if (I === _) return Y;
+            if (T === _) return Y;
           }
         }
         return M ?? "";
@@ -5695,14 +5695,14 @@ var y;
         const x = w[0], N = w[w.length - 1];
         if (x === '"' && N === '"' || x === "'" && N === "'")
           return w.slice(1, -1);
-        const I = w.toLowerCase();
-        if (I === "true") return !0;
-        if (I === "false") return !1;
+        const T = w.toLowerCase();
+        if (T === "true") return !0;
+        if (T === "false") return !1;
         if (/^-?\d+(\.\d+)?$/.test(w)) return parseFloat(w);
-        const T = u?.[w];
-        if (T === void 0) return w;
-        const M = String(T).trim(), E = M.toLowerCase();
-        return E === "true" ? !0 : E === "false" ? !1 : /^-?\d+(\.\d+)?$/.test(M) ? parseFloat(M) : T;
+        const I = u?.[w];
+        if (I === void 0) return w;
+        const M = String(I).trim(), E = M.toLowerCase();
+        return E === "true" ? !0 : E === "false" ? !1 : /^-?\d+(\.\d+)?$/.test(M) ? parseFloat(M) : I;
       }
       function W(r) {
         if (typeof r == "boolean") return r;
@@ -5717,18 +5717,18 @@ var y;
         for (; w.startsWith("!"); )
           x = !x, w = w.slice(1).trim();
         const N = ["===", "!==", "==", "!=", ">=", "<=", ">", "<"];
-        let I = null, T = w, M = "";
+        let T = null, I = w, M = "";
         for (const H of N) {
           const _ = w.indexOf(H);
           if (_ !== -1) {
-            I = H, T = w.slice(0, _), M = w.slice(_ + H.length);
+            T = H, I = w.slice(0, _), M = w.slice(_ + H.length);
             break;
           }
         }
         let E;
-        if (I) {
-          const H = V(T, u), _ = V(M, u);
-          switch (I) {
+        if (T) {
+          const H = V(I, u), _ = V(M, u);
+          switch (T) {
             case "===":
               E = H === _;
               break;
@@ -5758,7 +5758,7 @@ var y;
               break;
           }
         } else {
-          const H = V(T, u);
+          const H = V(I, u);
           E = W(H);
         }
         return x ? !E : E;
@@ -5769,20 +5769,20 @@ var y;
         let x = !1;
         for (; w.startsWith("!"); )
           x = !x, w = w.slice(1).trim();
-        const N = w.split("||").map((T) => T.trim()).filter((T) => T.length);
+        const N = w.split("||").map((I) => I.trim()).filter((I) => I.length);
         if (!N.length) return !!x;
-        let I = !1;
-        for (const T of N) {
-          const M = T.split("&&").map((H) => H.trim()).filter((H) => H.length);
+        let T = !1;
+        for (const I of N) {
+          const M = I.split("&&").map((H) => H.trim()).filter((H) => H.length);
           if (!M.length) continue;
           let E = !0;
           for (const H of M) {
             const _ = F(H, u);
             if (E = E && _, !E) break;
           }
-          if (I = I || E, I) break;
+          if (T = T || E, T) break;
         }
-        return x ? !I : I;
+        return x ? !T : T;
       }
       const at = {
         COLOR: (r, u) => l(u && i.validate(u) ? `color: ${u}` : "", r, "color"),
@@ -5817,24 +5817,24 @@ var y;
           MAP: (r, u, w) => O(r, u, w),
           ESCAPE: (r) => z(r),
           IF: (r, u, w) => {
-            const x = r ?? "", [N, I] = x.split("?", 2);
-            if (!I) return x;
-            const [T, M = ""] = I.split("|", 2);
-            return B(N, w) ? T : M;
+            const x = r ?? "", [N, T] = x.split("?", 2);
+            if (!T) return x;
+            const [I, M = ""] = T.split("|", 2);
+            return B(N, w) ? I : M;
           },
           PRESET: (r, u) => {
             const w = u?.trim() ?? "";
             if (!w.length) return r;
             const x = n.PRESETS[w];
             if (!x || !x.length) return r;
-            const N = x.split(",").map((T) => T.trim()).filter((T) => T.length).map((T) => {
-              const [M, E] = T.split(":");
+            const N = x.split(",").map((I) => I.trim()).filter((I) => I.length).map((I) => {
+              const [M, E] = I.split(":");
               return { name: M.trim(), param: E?.trim() ?? null };
             });
-            let I = r;
-            for (const { name: T, param: M } of N)
-              I = K(I, T, M);
-            return I;
+            let T = r;
+            for (const { name: I, param: M } of N)
+              T = K(T, I, M);
+            return T;
           },
           FALLBACK: (r, u) => r.length ? r : u ?? r
         },
@@ -5871,22 +5871,22 @@ var y;
         ...d.aliases ?? {}
       };
       function K(r, u, w) {
-        const x = Object.entries(ct).find(([I, T]) => T.some((M) => M.toUpperCase() === u.toUpperCase()) ? !0 : I.toUpperCase() === u.toUpperCase()), N = x ? x[0] : u.toUpperCase();
+        const x = Object.entries(ct).find(([T, I]) => I.some((M) => M.toUpperCase() === u.toUpperCase()) ? !0 : T.toUpperCase() === u.toUpperCase()), N = x ? x[0] : u.toUpperCase();
         try {
           return ot[N] ? ot[N](r, typeof w == "string" ? w.trim() : null, k) : d?.html ? l("", r, N.toLowerCase()) : r;
-        } catch (I) {
-          return d?.debug && typeof console < "u" && typeof console.error == "function" && console.error("[Helper.string.compose] Modifier error", { name: u, param: w, error: I }), r;
+        } catch (T) {
+          return d?.debug && typeof console < "u" && typeof console.error == "function" && console.error("[Helper.string.compose] Modifier error", { name: u, param: w, error: T }), r;
         }
       }
       function st(r) {
         let u = r, w;
         for (; (w = j.MODIFIERS.exec(u)) !== null; ) {
-          const [x, N, I] = w, T = N.split(",").map((E) => E.trim()).filter((E) => E.length).map((E) => {
+          const [x, N, T] = w, I = N.split(",").map((E) => E.trim()).filter((E) => E.length).map((E) => {
             const [H, _] = E.split(":");
             return { name: H.trim(), param: _?.trim() ?? null };
           });
-          let M = st(I);
-          for (const { name: E, param: H } of T)
+          let M = st(T);
+          for (const { name: E, param: H } of I)
             M = K(M, E, H);
           u = u.replace(x, M ?? ""), j.MODIFIERS.lastIndex = 0;
         }
@@ -5895,23 +5895,23 @@ var y;
       function X(r) {
         let u = 0;
         const w = r.length;
-        function x(I) {
-          let T = "";
+        function x(T) {
+          let I = "";
           for (; u < w; )
             if (r[u] === "\\")
-              u + 1 < w ? (T += r[u + 1], u += 2) : u++;
-            else if (r[u] === "[" && (!I || I !== "["))
-              T += N();
-            else if (I && r[u] === I) {
+              u + 1 < w ? (I += r[u + 1], u += 2) : u++;
+            else if (r[u] === "[" && (!T || T !== "["))
+              I += N();
+            else if (T && r[u] === T) {
               u++;
               break;
             } else
-              T += r[u++];
-          return T;
+              I += r[u++];
+          return I;
         }
         function N() {
           u++;
-          const I = [];
+          const T = [];
           for (; u < w && r[u] !== "="; ) {
             if (r[u] === ",") {
               u++;
@@ -5926,11 +5926,11 @@ var y;
               for (; u < w && r[u] !== "," && r[u] !== "="; ) u++;
               E = r.slice(H, u);
             }
-            M.length && I.push({ name: M, param: E }), r[u] === "," && u++;
+            M.length && T.push({ name: M, param: E }), r[u] === "," && u++;
           }
           r[u] === "=" && u++;
-          const T = x("]");
-          return I.reduce((M, { name: E, param: H }) => K(M, E, H), T);
+          const I = x("]");
+          return T.reduce((M, { name: E, param: H }) => K(M, E, H), I);
         }
         return x();
       }
@@ -6090,7 +6090,7 @@ var y;
 })(y || (y = {}));
 class it {
   constructor(e) {
-    this.field = "button", this.template = "button", this.name = "Button", this.value = "", window.client instanceof G && (this.field = e.field ?? this.field, this.template = e.template ?? this.template, this.name = e.name ?? this.name, this.value = e.value ?? this.value, this.run = e.run, window.client.actions.buttons.push(this), window.client.emit("action", this, "created"));
+    this.field = "button", this.template = "button", this.name = "Button", this.value = "", window.client instanceof G && (this.field = e.field ?? this.field, this.template = e.template ?? (typeof this.field == "string" ? this.field : this.template), this.name = e.name ?? this.name, this.value = e.value ?? this.value, this.run = e.run, window.client.actions.buttons.push(this), window.client.emit("action", this, "created"));
   }
   generate(e) {
     return y.utils.typedValues(e).reduce(
@@ -7180,14 +7180,18 @@ class mt extends Z {
     });
   }
   enqueue(e, t = {}) {
-    const a = {
-      isoDate: (/* @__PURE__ */ new Date()).toISOString(),
-      isLoop: t?.isLoop ?? !1,
-      isPriority: t?.isPriority ?? !1,
-      isImmediate: t?.isImmediate ?? !1,
-      value: e
-    }, i = this.hasItems();
-    return a.isPriority && a.isImmediate ? (this.cancel(), this.priorityQueue.unshift(a)) : (a.isPriority ? this.priorityQueue : this.queue).push(a), this.running === !1 && i === !1 && this.run(), this.emit("update", this.queue, this.priorityQueue, this.history, this.timeouts), this;
+    const a = this.hasItems(), i = Array.isArray(e) ? e.map((s) => ({ value: s.value, options: s.options ?? {} })) : [{ value: e, options: t }];
+    for (const s of i) {
+      const n = {
+        isoDate: (/* @__PURE__ */ new Date()).toISOString(),
+        isLoop: s.options?.isLoop ?? !1,
+        isPriority: s.options?.isPriority ?? !1,
+        isImmediate: s.options?.isImmediate ?? !1,
+        value: s.value
+      };
+      n.isPriority && n.isImmediate ? (this.cancel(), this.priorityQueue.unshift(n)) : (n.isPriority ? this.priorityQueue : this.queue).push(n);
+    }
+    return this.running === !1 && a === !1 && this.run(), this.emit("update", this.queue, this.priorityQueue, this.history, this.timeouts), this;
   }
   async run() {
     if (!this.hasItems()) {
@@ -7211,15 +7215,44 @@ class mt extends Z {
     const t = e.isPriority ? this.priorityQueue : this.queue;
     e.isLoop && t.push(e);
   }
+  /**
+   * Resume processing the queue if it is paused. If the queue is already running, it will be restarted, which can be useful if new items have been added or if you want to reset the processing timer.
+   * If the queue was empty before, it will start processing immediately.
+   * @returns - The instance of the queue for chaining.
+   * @example
+   * ```javascript
+   * myQueue.resume();
+   * ```
+   */
   resume() {
     return this.running && this.cancel(), this.hasItems() && this.run(), this;
   }
+  /**
+   * Update the queue's state with new values. This can be used to replace the current queue, priority queue, history, or timeouts with new data. If the queue is not currently running and there are items in the queue after the update, it will start processing immediately.
+   * @param save - An object containing the new state for the queue, priority queue, history, and timeouts. Each property is optional, and if not provided, the current state will be retained.
+   * @returns - The instance of the queue for chaining.
+   * @example
+   * ```javascript
+   * myQueue.update({
+   *   queue: newQueueItems,
+   *   priorityQueue: newPriorityItems,
+   *   history: newHistory,
+   * });
+   * ```
+   */
   update(e) {
     return this.queue = e.queue ?? this.queue, this.priorityQueue = e.priorityQueue ?? this.priorityQueue, this.history = e.history ?? this.history, this.hasItems() && this.running === !1 && window.client?.on("load", () => this.run()), this;
   }
+  /**
+   * Cancel all pending timeouts and stop the queue from processing further items. This will clear any scheduled processing and prevent any new items from being processed until `resume()` is called again. The current state of the queue, priority queue, and history will be retained, allowing you to resume processing later without losing any data.
+   */
   cancel() {
     this.running && (this.timeouts.forEach((e) => clearTimeout(e)), this.timeouts = [], this.running = !1, this.emit("cancel"));
   }
+  /**
+   * Check if there are any items in the queue or priority queue. This method returns `true` if there are items waiting to be processed in either the main queue or the priority queue, and `false` if both queues are empty.
+   * @returns - A boolean indicating whether there are items in the queue or priority queue.
+   */
   hasItems() {
     return this.queue.length > 0 || this.priorityQueue.length > 0;
   }
@@ -7449,7 +7482,7 @@ const nt = {
     list: {}
   }
 };
-async function Tt() {
+async function It() {
   let h = localStorage.getItem("SE_API-STORE") ?? "", e = h ? JSON.parse(h) : {};
   return nt.store.list = e, nt;
 }
@@ -7748,7 +7781,7 @@ class ut {
     !this.enabled || !console.timeEnd || console.timeEnd(e);
   }
 }
-const gt = typeof SE_API < "u" ? Promise.resolve(SE_API) : Promise.resolve(Tt()), R = new ut(), ht = {
+const gt = typeof SE_API < "u" ? Promise.resolve(SE_API) : Promise.resolve(It()), R = new ut(), ht = {
   SeAPI: gt,
   Client: G,
   Helper: y,