- Fixed drops logic

- Modified `class Recording` to better handle recording logic
- Removed `class Async`

Author: Ephellon

CHANGELOG.md

@@ -79,6 +79,11 @@
 ----
 
 # DONE — Notable Changes
+> [`5.33.4.20`](https://github.com/Ephellon/Twitch-Tools/releases/tag/5.33.4.20)
+- Fixed drops logic
+- Fixed `class Recording` logic
+- Removed `class Async`
+
 > [`5.33.4.19`](https://github.com/Ephellon/Twitch-Tools/releases/tag/5.33.4.19)
 - Used AI to fix some the following...
     + `ƒ nullish` when parsing raw `NaN`

ttv-tools.zip

@@ -780,337 +780,6 @@ class Tooltip {
     }
 };
 
-/**
- * Creates an asynchronous construct similar to a Promise. The only difference is that it accepts a spread (array) of arguments for its resolver and/or rejector.
- * @simply new Async(ƒ (onResolve, onReject)) → Async<#Promise>
- *
- * @author Medium {@link https://medium.com/@manojsingh047/polyfill-for-javascript-promise-81053b284e37 @manojsingh047}
- * @see https://medium.com/@manojsingh047/polyfill-for-javascript-promise-81053b284e37
- */
-class Async {
-    /** @typedef {string} AsyncStatus
-     * The status of an Async (Promise-like) object
-     *
-     * @property {string} PENDING - Denotes a pending (not resolved or rejected) Async
-     * @property {string} FULFILLED - Denotes a fulfilled (resolved) Async
-     * @property {string} REJECTED - Denotes a rejected (rejected) Async
-     */
-    static PENDING = 'pending';
-    static FULFILLED = 'fulfilled';
-    static REJECTED = 'rejected';
-
-    #resolvers = [];
-    #values;
-
-    #rejectors = [];
-    #errors;
-
-    #chain = [];
-
-    #status = Async.PENDING;
-    #volley = Async.PENDING;
-    #called = false;
-    #settled = false;
-    #fulfilled = false;
-    #rejected = false;
-
-    /** @constructor
-     *
-     * @param  {function} executor The same arguments for Promises: a resolver, and (optional) rejector.
-     * @return {Async}             Returns a Promise-like object
-     */
-    constructor(executor) {
-        return executor(this.#resolver.bind(this), this.#rejector.bind(this));
-    }
-
-    /**
-     * A method to chain Promise-like resolutions.
-     * Returns an {Async} object, allowing you to chain calls to other async methods.
-     * Similar to {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/then Promise.prototype.then}.
-     *
-     * @param  {function} callback  The function to call when the previous {Async} or <b>then</b> fulfills
-     * @return {Async}              The values that the {Async} or previous <b>then</b> was fulfilled with
-     */
-    then(callback) {
-        this.#resolvers.push(callback);
-        this.#chain.push(callback);
-
-        Object.defineProperties(callback, { signal: { value: Async.FULFILLED } });
-
-        return this;
-    }
-
-    /**
-     * A method to chain Promise-like rejections.
-     * Returns an {Async} object, allowing you to chain calls to other async methods.
-     * Similar to {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/catch Promise.prototype.catch}.
-     *
-     * @param  {function} callback  The function to call when the previous {Async} or <b>catch</b> rejects
-     * @return {Async}              The errors that the {Async} or previous <b>catch</b> was rejected with
-     */
-    catch(callback) {
-        this.#rejectors.push(callback);
-        this.#chain.push(callback);
-
-        Object.defineProperties(callback, { signal: { value: Async.REJECTED } });
-
-        return this;
-    }
-
-    /**
-     * A method to terminate Promise-like streams.
-     * Returns an {Async} object, allowing you to chain calls to other async methods.
-     * Similar to {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/finally Promise.prototype.finally}.
-     *
-     * @param  {function} callback  The function to call when the previous {Async} or <b>then</b> fulfills
-     * @return {Async}              The values that the {Async} or previous <b>then</b> was fulfilled with
-     */
-    finally(callback) {
-        this.#chain.push(callback);
-
-        return this;
-    }
-
-    /**
-     * Returns the status of the Async
-     *
-     * @return {AsyncStatus}  Returns the pending status of the Async
-     */
-    status() {
-        let pending = Symbol(Async.PENDING);
-
-        return Async.race([this, pending]).then(response => response === pending? Async.PENDING: Async.FULFILLED, () => Async.REJECTED);
-    }
-
-    /**
-     * Returns a resolved {Async} object.
-     * Similar to {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/resolve Promise.resolve}.
-     *
-     * @param  {any} [...values] The values to pass to the following <b>then</b>
-     * @return {any[]}      All of the values that were given
-     */
-    static resolve(...values) {
-        return new Async(function(resolve, reject) {
-            resolve.apply(this, values);
-        });
-    }
-
-    /**
-     * Returns a rejected {Async} object.
-     * Similar to {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/reject Promise.reject}.
-     *
-     * @param  {any} [...errors] The errors to pass to the following <b>catch</b>
-     * @return {Error[]}    All of the errors that were caught
-     */
-    static reject(...errors) {
-        return new Async(function(resolve, reject) {
-            reject.apply(this, errors);
-        });
-    }
-
-    /**
-     * Returns an array once <strong>all</strong> Asyncs have fulfilled.
-     * Similar to {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/all Promise.all}.
-     *
-     * @param  {Async} [...asyncs]  The Asyncs to iterate and wait for fulfillment
-     * @return {(Async|Error)}      This will fulfill to a promise or the first rejection
-     */
-    static all(asyncs) {
-        return new Async(function(resolve, reject) {
-            let finished = 0;
-            let responses = [];
-
-            if(asyncs.length == 0)
-                return resolve(asyncs);
-
-            for(let index = 0; index < asyncs.length; ++index)
-                asyncs[index]
-                    .then((...values) => done(values, index))
-                    .catch((...errors) => reject.apply(this, errors));
-
-            function done(values, index) {
-                ++finished;
-                responses[index] = values;
-
-                if(finished == asyncs.length)
-                    resolve.apply(this, values);
-            }
-        });
-    }
-
-    /**
-     * Returns an array of Async statuses.
-     * Similar to {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/allSettled Promise.allSettled}.
-     *
-     * @param  {Async} [...asyncs]  The Asyncs to iterate and retrieve statuses from
-     * @return {object[]}      This will be an array of objects that describe each Async's status
-     */
-    static allSettled(asyncs) {
-        return new Async(function(resolve, reject) {
-            let settled = 0;
-            let statuses = [];
-
-            for(let index = 0; index < asyncs.length; ++index)
-                asyncs[index]
-                    .then((...values) => done(values, index))
-                    .catch((...errors) => fail(errors, index));
-
-            function done(values, index) {
-                ++settled;
-                statuses[index] = { status: 'fulfilled', values };
-
-                if(settled == asyncs.length)
-                    resolve.apply(this, statuses);
-            }
-
-            function fail(reasons, index) {
-                ++settled;
-                statuses[index] = { status: 'rejected', reasons };
-
-                if(settled == asyncs.length)
-                    resolve.apply(this, statuses);
-            }
-        });
-    }
-
-    /**
-     * Returns the first fulfilled Async, or an array of rejections.
-     * Similar to {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/any Promise.any}.
-     *
-     * @param  {Async} [...asyncs]      The Asyncs to iterate
-     * @return {(any|AggregateError)}   This will be a fulfillment or AggregateError (array)
-     */
-    static any(asyncs) {
-        return new Async(function(resolve, reject) {
-            let failed = 0;
-            let reasons = [];
-
-            if(asyncs.length == 0)
-                return resolve(asyncs);
-
-            for(let index = 0; index < asyncs.length; ++index)
-                asyncs[index]
-                    .then((...values) => resolve.apply(this, values))
-                    .catch((...errors) => fail(errors, index));
-
-            function fail(errors, index) {
-                ++failed;
-                reasons[index] = errors;
-
-                if(failed == asyncs.length)
-                    reject.apply(this, new AggregateError(errors));
-            }
-        });
-    }
-
-    /**
-     * Returns the first fulfilled Async, or an array of rejections.
-     *
-     * @param  {Async} [...asyncs]  The Asyncs to iterate
-     * @return {(any|Error[])} This will be a fulfillment or array of rejections
-     */
-    static anySettled(asyncs) {
-        let errors = new Array(asyncs.length);
-        let errd = 0;
-
-        return new Async((resolve, reject) => {
-            asyncs.map((promise, index) => {
-                Async.resolve(promise)
-                    // Resolve the async to a non-empty value
-                    .then(result => {
-                        if(nullish(result))
-                            throw result;
-                        resolve(result);
-                    })
-                    // Reject the value, immediately
-                    .catch(error => {
-                        errors[index] = error;
-
-                        // All asyncs rejected; reject parent
-                        if(++errd == promises.length)
-                            reject(errors);
-                    });
-            });
-        });
-    }
-
-    /**
-     * Returns the first fulfilled Async.
-     * Similar to {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/race Promise.race}.
-     *
-     * @param  {Async} [...asyncs]  The Asyncs to iterate
-     * @return {Async}              This will be a fulfillment or AggregateError (array)
-     */
-    static race(asyncs) {
-        return new Async(function(resolve, reject) {
-            for(let async of asyncs)
-                async
-                    .then((...values) => resolve.apply(this, values))
-                    .catch((...errors) => reject.apply(this, errors));
-        });
-    }
-
-    #resolver(...values) {
-        this.#status = Async.FULFILLED;
-        this.#volley = Async.FULFILLED;
-        this.#fulfilled = true;
-        this.#settled = true;
-        this.#values = values;
-
-        if(!this.#called) {
-            this.#called = true;
-
-            chaining: for(let callback of this.#chain)
-                if(!callback.consumed) {
-                    if(callback.signal && (this.#status != callback.signal) && (this.#volley != callback.signal))
-                        continue chaining;
-
-                    Object.defineProperties(callback, { consumed: { value: true } });
-
-                    let values = this.#values;
-
-                    if(!(values instanceof Array))
-                        values = Array.of(values);
-
-                    // If an error is raised within a `then` callback, raise the error and deviate to the `catch` chain
-                    try {
-                        this.#values = callback.apply(this, values);
-                    } catch(error) {
-                        this.#volley = Async.REJECTED;
-                    }
-                }
-        }
-    }
-
-    #rejector(...errors) {
-        this.#status = Async.REJECTED;
-        this.#volley = Async.REJECTED;
-        this.#rejected = true;
-        this.#settled = true;
-        this.#errors = errors;
-
-        if(!this.#called) {
-            this.#called = true;
-
-            chaining: for(let callback of this.#chain)
-                if(!callback.consumed) {
-                    if(callback.signal && (this.#status != callback.signal) && (this.#volley != callback.signal))
-                        continue chaining;
-
-                    Object.defineProperties(callback, { consumed: { value: true } });
-
-                    let errors = this.#errors;
-
-                    if(!(errors instanceof Array))
-                        errors = Array.of(errors);
-
-                    // Errors cannot be volleyed back :P
-                    this.#errors = callback.apply(this, errors);
-                }
-        }
-    }
-}
-
 /** @typedef {string} CSSSelector
  * See {@link https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_selectors CSS selectors}
  */