tiny-essentials 1.4.0 → 1.5.0

package/dist/v1/libs/TinyPromiseQueue.cjs

@@ -0,0 +1,175 @@
+'use strict';
+
+/**
+ * A queue system for managing and executing asynchronous tasks sequentially, one at a time.
+ *
+ * Tasks can be delayed, reordered, canceled, and processed in strict order. The queue ensures that each task
+ * is executed after the previous one finishes, and any task can be skipped or canceled if needed.
+ *
+ * @class
+ */
+class TinyPromiseQueue {
+  /**
+   * @typedef {Object} QueuedTask
+   * @property {() => Promise<any>} task - The async task to execute.
+   * @property {(value: any) => any} resolve - The resolve function from the Promise.
+   * @property {(reason?: any) => any} reject - The reject function from the Promise.
+   * @property {string|undefined} [id] - Optional identifier for the task.
+   * @property {number|null|undefined} [delay] - Optional delay (in ms) before the task is executed.
+   */
+
+  /** @type {Array<QueuedTask>} */
+  #queue = [];
+  #running = false;
+  /** @type {Record<string, *>} */
+  #timeouts = {};
+  /** @type {Set<string>} */
+  #blacklist = new Set();
+
+  /**
+   * Returns whether the queue is currently processing a task.
+   *
+   * @returns {boolean}
+   */
+  isRunning() {
+    return this.#running;
+  }
+
+  /**
+   * Processes the next task in the queue if not already running.
+   * Ensures tasks are executed in order, one at a time.
+   *
+   * @returns {Promise<void>}
+   */
+  async #processQueue() {
+    if (this.#running || this.#queue.length === 0) return;
+    this.#running = true;
+    const data = this.#queue.shift();
+    if (
+      data &&
+      typeof data.task === 'function' &&
+      typeof data.resolve === 'function' &&
+      typeof data.reject === 'function'
+    ) {
+      const { task, resolve, reject, delay, id } = data;
+      try {
+        if (delay && id) {
+          await new Promise((resolveDelay) => {
+            const timeoutId = setTimeout(() => {
+              delete this.#timeouts[id];
+              resolveDelay(null);
+            }, delay);
+            this.#timeouts[id] = timeoutId;
+          });
+        }
+
+        if (id && this.#blacklist.has(id)) {
+          reject(new Error('The function was canceled on TinyPromiseQueue.'));
+          this.#blacklist.delete(id);
+          this.#running = false;
+          this.#processQueue();
+          return;
+        }
+
+        const result = await task();
+        resolve(result);
+      } catch (error) {
+        reject(error);
+      } finally {
+        this.#running = false;
+        this.#processQueue();
+      }
+    }
+  }
+
+  /**
+   * Returns the index of a task by its ID.
+   *
+   * @param {string} id The ID of the task to locate.
+   * @returns {number} The index of the task in the queue, or -1 if not found.
+   */
+  getIndexById(id) {
+    return this.#queue.findIndex((item) => item.id === id);
+  }
+
+  /**
+   * Returns a list of IDs for all tasks currently in the queue.
+   *
+   * @returns {{ index: number, id: string }[]} An array of task IDs currently queued.
+   */
+  getQueuedIds() {
+    // @ts-ignore
+    return this.#queue
+      .map((item, index) => ({ index, id: item.id }))
+      .filter((entry) => typeof entry.id === 'string');
+  }
+
+  /**
+   * Reorders a task in the queue from one index to another.
+   *
+   * @param {number} fromIndex The current index of the task to move.
+   * @param {number} toIndex The index where the task should be placed.
+   */
+  reorderQueue(fromIndex, toIndex) {
+    if (
+      typeof fromIndex !== 'number' ||
+      typeof toIndex !== 'number' ||
+      fromIndex < 0 ||
+      toIndex < 0 ||
+      fromIndex >= this.#queue.length ||
+      toIndex >= this.#queue.length
+    )
+      return;
+    const [item] = this.#queue.splice(fromIndex, 1);
+    this.#queue.splice(toIndex, 0, item);
+  }
+
+  /**
+   * Adds a new async task to the queue and ensures it runs in order after previous tasks.
+   * Optionally, a delay can be added before the task is executed.
+   *
+   * If the task is canceled before execution, it will be rejected with the message:
+   * "The function was canceled on TinyPromiseQueue."
+   *
+   * @param {(...args: any[]) => Promise<any>} task A function that returns a Promise to be executed sequentially.
+   * @param {number|null} [delay] Optional delay (in ms) before the task is executed.
+   * @param {string} [id] Optional ID to identify the task in the queue.
+   * @returns {Promise<any>} A Promise that resolves or rejects with the result of the task once it's processed.
+   */
+  enqueue(task, delay, id) {
+    return new Promise((resolve, reject) => {
+      this.#queue.push({ task, resolve, reject, id, delay });
+      this.#processQueue();
+    });
+  }
+
+  /**
+   * Cancels a scheduled delay and removes the task from the queue.
+   * Adds the ID to a blacklist so the task is skipped if already being processed.
+   *
+   * @param {string} id The ID of the task to cancel.
+   * @returns {boolean} True if a delay was cancelled and the task was removed.
+   */
+  cancelTask(id) {
+    if (!id) return false;
+    let cancelled = false;
+
+    if (id in this.#timeouts) {
+      clearTimeout(this.#timeouts[id]);
+      delete this.#timeouts[id];
+      cancelled = true;
+    }
+
+    const index = this.getIndexById(id);
+    if (index !== -1) {
+      this.#queue.splice(index, 1);
+      cancelled = true;
+    }
+
+    if (cancelled) this.#blacklist.add(id);
+
+    return cancelled;
+  }
+}
+
+module.exports = TinyPromiseQueue;

package/dist/v1/libs/TinyPromiseQueue.d.mts

@@ -0,0 +1,63 @@
+export default TinyPromiseQueue;
+/**
+ * A queue system for managing and executing asynchronous tasks sequentially, one at a time.
+ *
+ * Tasks can be delayed, reordered, canceled, and processed in strict order. The queue ensures that each task
+ * is executed after the previous one finishes, and any task can be skipped or canceled if needed.
+ *
+ * @class
+ */
+declare class TinyPromiseQueue {
+    /**
+     * Returns whether the queue is currently processing a task.
+     *
+     * @returns {boolean}
+     */
+    isRunning(): boolean;
+    /**
+     * Returns the index of a task by its ID.
+     *
+     * @param {string} id The ID of the task to locate.
+     * @returns {number} The index of the task in the queue, or -1 if not found.
+     */
+    getIndexById(id: string): number;
+    /**
+     * Returns a list of IDs for all tasks currently in the queue.
+     *
+     * @returns {{ index: number, id: string }[]} An array of task IDs currently queued.
+     */
+    getQueuedIds(): {
+        index: number;
+        id: string;
+    }[];
+    /**
+     * Reorders a task in the queue from one index to another.
+     *
+     * @param {number} fromIndex The current index of the task to move.
+     * @param {number} toIndex The index where the task should be placed.
+     */
+    reorderQueue(fromIndex: number, toIndex: number): void;
+    /**
+     * Adds a new async task to the queue and ensures it runs in order after previous tasks.
+     * Optionally, a delay can be added before the task is executed.
+     *
+     * If the task is canceled before execution, it will be rejected with the message:
+     * "The function was canceled on TinyPromiseQueue."
+     *
+     * @param {(...args: any[]) => Promise<any>} task A function that returns a Promise to be executed sequentially.
+     * @param {number|null} [delay] Optional delay (in ms) before the task is executed.
+     * @param {string} [id] Optional ID to identify the task in the queue.
+     * @returns {Promise<any>} A Promise that resolves or rejects with the result of the task once it's processed.
+     */
+    enqueue(task: (...args: any[]) => Promise<any>, delay?: number | null, id?: string): Promise<any>;
+    /**
+     * Cancels a scheduled delay and removes the task from the queue.
+     * Adds the ID to a blacklist so the task is skipped if already being processed.
+     *
+     * @param {string} id The ID of the task to cancel.
+     * @returns {boolean} True if a delay was cancelled and the task was removed.
+     */
+    cancelTask(id: string): boolean;
+    #private;
+}
+//# sourceMappingURL=TinyPromiseQueue.d.mts.map

package/dist/v1/libs/TinyPromiseQueue.mjs

@@ -0,0 +1,159 @@
+/**
+ * A queue system for managing and executing asynchronous tasks sequentially, one at a time.
+ *
+ * Tasks can be delayed, reordered, canceled, and processed in strict order. The queue ensures that each task
+ * is executed after the previous one finishes, and any task can be skipped or canceled if needed.
+ *
+ * @class
+ */
+class TinyPromiseQueue {
+    /**
+     * @typedef {Object} QueuedTask
+     * @property {() => Promise<any>} task - The async task to execute.
+     * @property {(value: any) => any} resolve - The resolve function from the Promise.
+     * @property {(reason?: any) => any} reject - The reject function from the Promise.
+     * @property {string|undefined} [id] - Optional identifier for the task.
+     * @property {number|null|undefined} [delay] - Optional delay (in ms) before the task is executed.
+     */
+    /** @type {Array<QueuedTask>} */
+    #queue = [];
+    #running = false;
+    /** @type {Record<string, *>} */
+    #timeouts = {};
+    /** @type {Set<string>} */
+    #blacklist = new Set();
+    /**
+     * Returns whether the queue is currently processing a task.
+     *
+     * @returns {boolean}
+     */
+    isRunning() {
+        return this.#running;
+    }
+    /**
+     * Processes the next task in the queue if not already running.
+     * Ensures tasks are executed in order, one at a time.
+     *
+     * @returns {Promise<void>}
+     */
+    async #processQueue() {
+        if (this.#running || this.#queue.length === 0)
+            return;
+        this.#running = true;
+        const data = this.#queue.shift();
+        if (data &&
+            typeof data.task === 'function' &&
+            typeof data.resolve === 'function' &&
+            typeof data.reject === 'function') {
+            const { task, resolve, reject, delay, id } = data;
+            try {
+                if (delay && id) {
+                    await new Promise((resolveDelay) => {
+                        const timeoutId = setTimeout(() => {
+                            delete this.#timeouts[id];
+                            resolveDelay(null);
+                        }, delay);
+                        this.#timeouts[id] = timeoutId;
+                    });
+                }
+                if (id && this.#blacklist.has(id)) {
+                    reject(new Error('The function was canceled on TinyPromiseQueue.'));
+                    this.#blacklist.delete(id);
+                    this.#running = false;
+                    this.#processQueue();
+                    return;
+                }
+                const result = await task();
+                resolve(result);
+            }
+            catch (error) {
+                reject(error);
+            }
+            finally {
+                this.#running = false;
+                this.#processQueue();
+            }
+        }
+    }
+    /**
+     * Returns the index of a task by its ID.
+     *
+     * @param {string} id The ID of the task to locate.
+     * @returns {number} The index of the task in the queue, or -1 if not found.
+     */
+    getIndexById(id) {
+        return this.#queue.findIndex((item) => item.id === id);
+    }
+    /**
+     * Returns a list of IDs for all tasks currently in the queue.
+     *
+     * @returns {{ index: number, id: string }[]} An array of task IDs currently queued.
+     */
+    getQueuedIds() {
+        // @ts-ignore
+        return this.#queue
+            .map((item, index) => ({ index, id: item.id }))
+            .filter((entry) => typeof entry.id === 'string');
+    }
+    /**
+     * Reorders a task in the queue from one index to another.
+     *
+     * @param {number} fromIndex The current index of the task to move.
+     * @param {number} toIndex The index where the task should be placed.
+     */
+    reorderQueue(fromIndex, toIndex) {
+        if (typeof fromIndex !== 'number' ||
+            typeof toIndex !== 'number' ||
+            fromIndex < 0 ||
+            toIndex < 0 ||
+            fromIndex >= this.#queue.length ||
+            toIndex >= this.#queue.length)
+            return;
+        const [item] = this.#queue.splice(fromIndex, 1);
+        this.#queue.splice(toIndex, 0, item);
+    }
+    /**
+     * Adds a new async task to the queue and ensures it runs in order after previous tasks.
+     * Optionally, a delay can be added before the task is executed.
+     *
+     * If the task is canceled before execution, it will be rejected with the message:
+     * "The function was canceled on TinyPromiseQueue."
+     *
+     * @param {(...args: any[]) => Promise<any>} task A function that returns a Promise to be executed sequentially.
+     * @param {number|null} [delay] Optional delay (in ms) before the task is executed.
+     * @param {string} [id] Optional ID to identify the task in the queue.
+     * @returns {Promise<any>} A Promise that resolves or rejects with the result of the task once it's processed.
+     */
+    enqueue(task, delay, id) {
+        return new Promise((resolve, reject) => {
+            this.#queue.push({ task, resolve, reject, id, delay });
+            this.#processQueue();
+        });
+    }
+    /**
+     * Cancels a scheduled delay and removes the task from the queue.
+     * Adds the ID to a blacklist so the task is skipped if already being processed.
+     *
+     * @param {string} id The ID of the task to cancel.
+     * @returns {boolean} True if a delay was cancelled and the task was removed.
+     */
+    cancelTask(id) {
+        if (!id)
+            return false;
+        let cancelled = false;
+        if (id in this.#timeouts) {
+            clearTimeout(this.#timeouts[id]);
+            delete this.#timeouts[id];
+            cancelled = true;
+        }
+        const index = this.getIndexById(id);
+        if (index !== -1) {
+            this.#queue.splice(index, 1);
+            cancelled = true;
+        }
+        if (cancelled)
+            this.#blacklist.add(id);
+        return cancelled;
+    }
+}
+export default TinyPromiseQueue;

package/docs/README.md

@@ -17,6 +17,11 @@ This folder contains the core scripts we have worked on so far. Each file is a m
 - 🧠 **[objFilter.md](./basics/objFilter.md)** — Type detection, extension, and analysis made easy with simple and extensible type validation.
 - 🔢 **[simpleMath.md](./basics/simpleMath.md)** — A collection of simple math utilities for calculations like the Rule of Three and percentages.
 - ✍️ **[text.md](./basics/text.md)** — A utility for transforming text into title case formats, with multiple options for capitalization.
+- 🔄 **[asyncReplace.md](./basics/asyncReplace.md)** — Asynchronously replaces matches in a string using a regex and an async function.
+
+### 2. **`libs/`**
+- 🗂️ **[TinyPromiseQueue.md](./libs/TinyPromiseQueue.md)** — A class that allows sequential execution of asynchronous tasks, supporting task delays, cancellation, and queue management.
+- 🏅 **[TinyLevelUp.md](./libs/TinyLevelUp.md)** — A class to manage user level-up logic based on experience points, providing methods for experience validation, addition, removal, and calculation.
 
 ---
 

package/docs/basics/asyncReplace.md

@@ -0,0 +1,39 @@
+## `asyncReplace(str, regex, asyncFn)` 🔄
+
+Asynchronously replaces matches in a string using a regular expression and an async function.
+
+This function performs replacements on a string, allowing each match to be asynchronously replaced by calling an asynchronous function for each match. The asynchronous function should return a replacement value for each match and will receive the same arguments as the standard `replace` callback.
+
+### Parameters:
+
+- `str` (`string`): The input string to perform replacements on.
+- `regex` (`RegExp`): The regular expression used to match substrings for replacement.
+- `asyncFn` (`Function`): An asynchronous function that returns a replacement for each match. 
+    - It receives the same arguments as the standard `replace` callback (the matched substring and the matched string's groups).
+    - The function should return a `Promise` that resolves to the replacement value for that match.
+
+### Returns:
+- `Promise<string>`: A promise that resolves to the resulting string with all async replacements applied.
+
+### Example:
+
+```javascript
+await asyncReplace("Hello @user1 and @user2!", /@\w+/g, async (mention) => {
+  return await getUserNameFromMention(mention);
+});
+```
+
+In this example, each `@user` mention is asynchronously replaced by the value returned from `getUserNameFromMention`.
+
+### Description:
+
+This function will:
+1. Use a regular expression (`regex`) to find all matches in the input string (`str`).
+2. For each match, it will invoke the provided asynchronous function (`asyncFn`), which should return the replacement value.
+3. Once all promises are resolved, it replaces the original matches in the string with the resolved values.
+
+This is useful for scenarios where you need to replace parts of a string based on dynamic data (like fetching usernames from a server for each mention in a message).
+
+### Notes:
+- The replacements are performed asynchronously, ensuring non-blocking behavior when dealing with large or external data sources.
+- The function utilizes `Promise.all` to handle multiple asynchronous operations concurrently before replacing the matches in the original string.

package/docs/libs/TinyLevelUp.md

@@ -0,0 +1,108 @@
+
+### TinyLevelUp 🎮
+
+This class manages user level-up logic based on experience points. It provides methods to handle experience points (exp) adjustments, level progression, and random experience generation.
+
+#### Constructor 🛠️
+
+- **`constructor(giveExp: number, expLevel: number)`**  
+  Initializes the class with the base experience value for random experience generation and the base experience required to level up.
+
+  - `giveExp` (`number`): The base experience value used for random experience generation. 🎲
+  - `expLevel` (`number`): The base experience required to level up for each level. 📈
+
+#### Methods 🔧
+
+- **`expValidator(user: UserEditor)`**  
+  Validates and adjusts the user's level based on their current experience. If the user's experience is above or below the required threshold, their level is adjusted accordingly. ⚖️
+
+  - `user` (`UserEditor`): The user object containing `exp` (experience), `level` (current level), and `totalExp` (total experience). 👤
+  
+  - **Returns**: `UserResult` - The updated user object. 🔄
+
+- **`getTotalExp(user: { exp: number, level: number })`**  
+  Calculates the total experience based on the user's level and experience. 📊
+
+  - `user` (`Object`): The user object containing `exp` (experience) and `level` (level). 👤
+  
+  - **Returns**: `number` - The total experience of the user. 🔢
+
+- **`expGenerator(multi: number = 1)`**  
+  Generates random experience points based on a configured multiplier. 🎲
+
+  - `multi` (`number`): A multiplier for experience generation. Default is `1`. 💯
+
+  - **Returns**: `number` - The generated experience points. 💥
+
+- **`progress(user: { level: number })`**  
+  Gets the experience points required to reach the next level. ⏩
+
+  - `user` (`Object`): The user object containing the `level`. 👤
+
+  - **Returns**: `number` - The experience required for the next level. 📈
+
+- **`getProgress(user: { level: number })`**  
+  An alias for `progress`. Returns the experience points required to reach the next level. ⏩
+
+  - `user` (`Object`): The user object containing the `level`. 👤
+
+  - **Returns**: `number` - The experience required for the next level. 📈
+
+- **`set(user: UserEditor, value: number)`**  
+  Sets the user's experience value and adjusts their level if necessary. 📝
+
+  - `user` (`UserEditor`): The user object containing `exp`, `level`, and `totalExp`. 👤
+  - `value` (`number`): The new experience value to set for the user. 💡
+
+  - **Returns**: `UserResult` - The updated user object. 🔄
+
+- **`give(user: UserEditor, extraExp: number = 0, type: 'add' | 'extra' = 'add', multi: number = 1)`**  
+  Adds experience to the user and adjusts their level if necessary. Experience can be added with or without a multiplier. ➕
+
+  - `user` (`UserEditor`): The user object containing `exp`, `level`, and `totalExp`. 👤
+  - `extraExp` (`number`): Additional experience to be added. 💯
+  - `type` (`'add' | 'extra'`): Type of experience addition. `'add'` adds random experience, while `'extra'` adds specified experience. 🔧
+  - `multi` (`number`): Multiplier for experience generation. Default is `1`. 💥
+
+  - **Returns**: `UserResult` - The updated user object. 🔄
+
+- **`remove(user: UserEditor, extraExp: number = 0, type: 'add' | 'extra' = 'add', multi: number = 1)`**  
+  Removes experience from the user and adjusts their level if necessary. Experience can be removed with or without a multiplier. ➖
+
+  - `user` (`UserEditor`): The user object containing `exp`, `level`, and `totalExp`. 👤
+  - `extraExp` (`number`): Additional experience to be removed. 💣
+  - `type` (`'add' | 'extra'`): Type of experience removal. `'add'` removes random experience, while `'extra'` removes specified experience. 🔧
+  - `multi` (`number`): Multiplier for experience generation. Default is `1`. 💥
+
+  - **Returns**: `UserResult` - The updated user object. 🔄
+
+### Type Definitions 📚
+
+- **`UserResult`**  
+  Represents the structure of a user object after level validation. 🧑‍💻
+
+  - `exp` (`number`): The user's experience. 🎯
+  - `level` (`number`): The user's current level. 🏆
+  - `totalExp` (`number`): The user's total experience. 📊
+
+- **`UserEditor`**  
+  Represents the user object before level validation. 🔧
+
+  - `exp` (`number`): The user's experience. 🎯
+  - `level` (`number`): The user's current level. 🏆
+  - `totalExp` (`any`): The user's total experience (can be calculated using `getTotalExp`). 📊
+
+### Example Usage 💡
+
+```javascript
+const user = { exp: 50, level: 1, totalExp: 50 };
+const levelUpSystem = new TinyLevelUp(100, 1000);
+
+// Add experience and check updated user stats
+levelUpSystem.give(user);
+console.log(user); // { exp: 112, level: 1, totalExp: 112 }
+```
+
+---
+
+This class can be used to manage user experience points and level-ups in any system requiring user progression logic. 🚀

package/docs/libs/TinyPromiseQueue.md

@@ -0,0 +1,126 @@
+# `TinyPromiseQueue` Documentation 🎉
+
+`TinyPromiseQueue` is a queue system designed to manage and execute asynchronous tasks in a sequential, one-at-a-time order. Tasks are executed in the order they are added to the queue, with support for optional delays ⏳, task cancellation ❌, and task reordering 🔄.
+
+---
+
+## Properties 🏠
+
+- **`#queue`**: The internal queue array that holds all the tasks.
+- **`#running`**: A flag indicating whether the queue is currently processing a task.
+- **`#timeouts`**: An object storing timeouts for scheduled delays.
+- **`#blacklist`**: A set of task IDs that should be skipped if already being processed or canceled.
+
+---
+
+## Methods 🛠️
+
+### `isRunning()` 🏃‍♀️
+
+Returns whether the queue is currently processing a task.
+
+#### Returns:
+- `boolean`: `true` if the queue is processing a task, otherwise `false`.
+
+### `getIndexById(id)` 🔍
+
+Returns the index of a task in the queue by its ID.
+
+#### Parameters:
+- `id` (`string`): The ID of the task to locate.
+
+#### Returns:
+- `number`: The index of the task in the queue, or `-1` if not found.
+
+### `getQueuedIds()` 📋
+
+Returns a list of IDs for all tasks currently in the queue.
+
+#### Returns:
+- `Array<{ index: number, id: string }>`: An array of task IDs and their corresponding indices.
+
+### `reorderQueue(fromIndex, toIndex)` 🔄
+
+Reorders a task in the queue from one index to another.
+
+#### Parameters:
+- `fromIndex` (`number`): The current index of the task to move.
+- `toIndex` (`number`): The index where the task should be placed.
+
+#### Returns:
+- `void`: This method does not return anything.
+
+### `enqueue(task, delay, id)` ⏳
+
+Adds a new async task to the queue and ensures it runs in order after previous tasks. Optionally, a delay can be added before the task is executed.
+
+If the task is canceled before execution, it will be rejected with the message:
+**"The function was canceled on TinyPromiseQueue."**
+
+#### Parameters:
+- `task` (`Function`): A function that returns a `Promise` to be executed sequentially.
+- `delay` (`number|null`): Optional delay (in ms) before the task is executed.
+- `id` (`string`): Optional ID to identify the task in the queue.
+
+#### Returns:
+- `Promise<any>`: A promise that resolves or rejects with the result of the task once it's processed.
+
+### `cancelTask(id)` ❌
+
+Cancels a scheduled delay and removes the task from the queue. Adds the ID to a blacklist so the task is skipped if already being processed.
+
+#### Parameters:
+- `id` (`string`): The ID of the task to cancel.
+
+#### Returns:
+- `boolean`: `true` if a delay was cancelled and the task was removed, otherwise `false`.
+
+---
+
+## Usage Example 💻
+
+```js
+import { TinyPromiseQueue } from './TinyPromiseQueue';
+
+const queue = new TinyPromiseQueue();
+
+// Helper function to create simple tasks with logs
+function createTask(name, duration = 500) {
+  return () => new Promise((resolve) => {
+    console.log(`Started task: ${name}`);
+    setTimeout(() => {
+      console.log(`Finished task: ${name}`);
+      resolve(name);
+    }, duration);
+  });
+}
+
+// Enqueue 3 tasks
+queue.enqueue(createTask('A'), 100, 'taskA');
+queue.enqueue(createTask('B'), 0, 'taskB');
+queue.enqueue(createTask('C'), 0, 'taskC');
+
+// Wait for 50ms and cancel taskB
+setTimeout(() => {
+  const success = queue.cancelTask('taskB');
+  console.log('Canceled taskB:', success); // true if cancelled
+}, 50);
+
+// List the remaining IDs in the queue
+setTimeout(() => {
+  const ids = queue.getQueuedIds();
+  console.log('Queued IDs:', ids);
+}, 60);
+```
+
+### Explanation 🧩:
+1. **Task Creation**: Tasks are created with a name and an optional duration (in ms). The task logs its start and finish times 🕰️.
+2. **Task Execution**: Tasks are enqueued one at a time, ensuring they run in the order they were added 🔁.
+3. **Cancellation**: After 50ms, taskB is canceled, demonstrating the ability to remove a task from the queue ❌.
+4. **Remaining Tasks**: The remaining tasks in the queue are logged after 60ms 📊.
+
+---
+
+## Conclusion 🎯
+
+`TinyPromiseQueue` provides a simple and effective way to manage a sequence of asynchronous tasks. With its support for delays ⏳, task cancellation ❌, and reordering 🔄, it allows for efficient control over task execution in JavaScript.