tiny-essentials 1.0.0

package/dist/legacy/libs/markdown.cjs

@@ -0,0 +1,85 @@
+'use strict';
+
+/**
+ * A lightweight Markdown parser that can convert to HTML or BBCode.
+ * @namespace markdownManager
+ */
+const markdownManager = {
+  /**
+   * Conversion rules for Markdown elements.
+   * Each rule includes a regex pattern, an HTML output, and a BBCode equivalent.
+   */
+  values: {
+    h3: {
+      regex: /^### (.*$)/gim,
+      result: '<h3>$1</h3>',
+      bbcode: '[h3]$1[/h3]',
+    },
+    h2: {
+      regex: /^## (.*$)/gim,
+      result: '<h2>$1</h2>',
+      bbcode: '[h2]$1[/h2]',
+    },
+    h1: {
+      regex: /^# (.*$)/gim,
+      result: '<h1>$1</h1>',
+      bbcode: '[h1]$1[/h1]',
+    },
+    blockquote: {
+      regex: /^\> (.*$)/gim,
+      result: '<blockquote>$1</blockquote>',
+      bbcode: '[blockquote]$1[/blockquote]',
+    },
+    strong: {
+      regex: /\*\*(.*)\*\*/gim,
+      result: '<strong>$1</strong>',
+      bbcode: '[b]$1[/b]',
+    },
+    italic: {
+      regex: /\*(.*)\*/gim,
+      result: '<i>$1</i>',
+      bbcode: '[i]$1[/i]',
+    },
+    image: {
+      regex: /!\[(.*?)\]\((.*?)\)/gim,
+      result: "<img alt='$1' src='$2' />",
+      bbcode: '[img="$2"]',
+    },
+    url: {
+      regex: /\[(.*?)\]\((.*?)\)/gim,
+      result: "<a href='$2'>$1</a>",
+      bbcode: '[href="$2"]$1[/i]',
+    },
+    br: {
+      regex: /\n$/gim,
+      result: '<br />',
+      bbcode: '\n',
+    },
+  },
+
+  /**
+   * Parses Markdown content into HTML or BBCode.
+   * @param {string} markdownText - The input Markdown string.
+   * @param {'result' | 'bbcode'} [type='result'] - The desired output type.
+   * @returns {string} The converted string.
+   *
+   * @example
+   * markdownManager.parseMarkdown("**bold**"); // <strong>bold</strong>
+   * markdownManager.parseMarkdown("**bold**", "bbcode"); // [b]bold[/b]
+   */
+  parseMarkdown: function (markdownText, type = 'result') {
+    let htmlText = markdownText;
+
+    for (const item in markdownManager.values) {
+      const rule = markdownManager.values[item];
+      const replacer = rule[type];
+
+      if (typeof replacer === 'string' || typeof replacer === 'function')
+        htmlText = htmlText.replace(rule.regex, replacer);
+    }
+
+    return htmlText.trim();
+  },
+};
+
+module.exports = markdownManager;

package/dist/legacy/libs/markdown.d.mts

@@ -0,0 +1,75 @@
+export default markdownManager;
+declare namespace markdownManager {
+    namespace values {
+        namespace h3 {
+            let regex: RegExp;
+            let result: string;
+            let bbcode: string;
+        }
+        namespace h2 {
+            let regex_1: RegExp;
+            export { regex_1 as regex };
+            let result_1: string;
+            export { result_1 as result };
+            let bbcode_1: string;
+            export { bbcode_1 as bbcode };
+        }
+        namespace h1 {
+            let regex_2: RegExp;
+            export { regex_2 as regex };
+            let result_2: string;
+            export { result_2 as result };
+            let bbcode_2: string;
+            export { bbcode_2 as bbcode };
+        }
+        namespace blockquote {
+            let regex_3: RegExp;
+            export { regex_3 as regex };
+            let result_3: string;
+            export { result_3 as result };
+            let bbcode_3: string;
+            export { bbcode_3 as bbcode };
+        }
+        namespace strong {
+            let regex_4: RegExp;
+            export { regex_4 as regex };
+            let result_4: string;
+            export { result_4 as result };
+            let bbcode_4: string;
+            export { bbcode_4 as bbcode };
+        }
+        namespace italic {
+            let regex_5: RegExp;
+            export { regex_5 as regex };
+            let result_5: string;
+            export { result_5 as result };
+            let bbcode_5: string;
+            export { bbcode_5 as bbcode };
+        }
+        namespace image {
+            let regex_6: RegExp;
+            export { regex_6 as regex };
+            let result_6: string;
+            export { result_6 as result };
+            let bbcode_6: string;
+            export { bbcode_6 as bbcode };
+        }
+        namespace url {
+            let regex_7: RegExp;
+            export { regex_7 as regex };
+            let result_7: string;
+            export { result_7 as result };
+            let bbcode_7: string;
+            export { bbcode_7 as bbcode };
+        }
+        namespace br {
+            let regex_8: RegExp;
+            export { regex_8 as regex };
+            let result_8: string;
+            export { result_8 as result };
+            let bbcode_8: string;
+            export { bbcode_8 as bbcode };
+        }
+    }
+    function parseMarkdown(markdownText: string, type?: "result" | "bbcode"): string;
+}

package/dist/legacy/libs/markdown.mjs

@@ -0,0 +1,78 @@
+/**
+ * A lightweight Markdown parser that can convert to HTML or BBCode.
+ * @namespace markdownManager
+ */
+const markdownManager = {
+    /**
+     * Conversion rules for Markdown elements.
+     * Each rule includes a regex pattern, an HTML output, and a BBCode equivalent.
+     */
+    values: {
+        h3: {
+            regex: /^### (.*$)/gim,
+            result: '<h3>$1</h3>',
+            bbcode: '[h3]$1[/h3]',
+        },
+        h2: {
+            regex: /^## (.*$)/gim,
+            result: '<h2>$1</h2>',
+            bbcode: '[h2]$1[/h2]',
+        },
+        h1: {
+            regex: /^# (.*$)/gim,
+            result: '<h1>$1</h1>',
+            bbcode: '[h1]$1[/h1]',
+        },
+        blockquote: {
+            regex: /^\> (.*$)/gim,
+            result: '<blockquote>$1</blockquote>',
+            bbcode: '[blockquote]$1[/blockquote]',
+        },
+        strong: {
+            regex: /\*\*(.*)\*\*/gim,
+            result: '<strong>$1</strong>',
+            bbcode: '[b]$1[/b]',
+        },
+        italic: {
+            regex: /\*(.*)\*/gim,
+            result: '<i>$1</i>',
+            bbcode: '[i]$1[/i]',
+        },
+        image: {
+            regex: /!\[(.*?)\]\((.*?)\)/gim,
+            result: "<img alt='$1' src='$2' />",
+            bbcode: '[img="$2"]',
+        },
+        url: {
+            regex: /\[(.*?)\]\((.*?)\)/gim,
+            result: "<a href='$2'>$1</a>",
+            bbcode: '[href="$2"]$1[/i]',
+        },
+        br: {
+            regex: /\n$/gim,
+            result: '<br />',
+            bbcode: '\n',
+        },
+    },
+    /**
+     * Parses Markdown content into HTML or BBCode.
+     * @param {string} markdownText - The input Markdown string.
+     * @param {'result' | 'bbcode'} [type='result'] - The desired output type.
+     * @returns {string} The converted string.
+     *
+     * @example
+     * markdownManager.parseMarkdown("**bold**"); // <strong>bold</strong>
+     * markdownManager.parseMarkdown("**bold**", "bbcode"); // [b]bold[/b]
+     */
+    parseMarkdown: function (markdownText, type = 'result') {
+        let htmlText = markdownText;
+        for (const item in markdownManager.values) {
+            const rule = markdownManager.values[item];
+            const replacer = rule[type];
+            if (typeof replacer === 'string' || typeof replacer === 'function')
+                htmlText = htmlText.replace(rule.regex, replacer);
+        }
+        return htmlText.trim();
+    },
+};
+export default markdownManager;

package/dist/legacy/libs/percentage.cjs

@@ -0,0 +1,22 @@
+'use strict';
+
+/**
+ * Simple utility to calculate percentage values.
+ * @namespace percentageBase
+ */
+const percentageBase = {
+  /**
+   * Calculates a percentage of a given base value.
+   * @param {number} preco - The base value.
+   * @param {number} porcentagem - The percentage to apply.
+   * @returns {number} The result of the percentage calculation.
+   *
+   * @example
+   * percentageBase.run(200, 15); // 30
+   */
+  run: function (preco, porcentagem) {
+    return preco * (porcentagem / 100);
+  },
+};
+
+module.exports = percentageBase;

package/dist/legacy/libs/percentage.d.mts

@@ -0,0 +1,4 @@
+export default percentageBase;
+declare namespace percentageBase {
+    function run(preco: number, porcentagem: number): number;
+}

package/dist/legacy/libs/percentage.mjs

@@ -0,0 +1,19 @@
+/**
+ * Simple utility to calculate percentage values.
+ * @namespace percentageBase
+ */
+const percentageBase = {
+    /**
+     * Calculates a percentage of a given base value.
+     * @param {number} preco - The base value.
+     * @param {number} porcentagem - The percentage to apply.
+     * @returns {number} The result of the percentage calculation.
+     *
+     * @example
+     * percentageBase.run(200, 15); // 30
+     */
+    run: function (preco, porcentagem) {
+        return preco * (porcentagem / 100);
+    },
+};
+export default percentageBase;

package/dist/legacy/libs/regex/getLetter.cjs

@@ -0,0 +1,22 @@
+'use strict';
+
+/**
+ * Matches exactly one letter (lowercase or uppercase).
+ * @param {string} [type='g'] - The flag for the regular expression (default is 'g').
+ * @returns {RegExp} The regular expression to match exactly one letter.
+ */
+function oneLetter(type = 'g') {
+  return new RegExp('^[a-zA-Z]+$', type); // Matches exactly one letter
+}
+
+/**
+ * Matches one or more letters (lowercase or uppercase).
+ * @param {string} [type='g'] - The flag for the regular expression (default is 'g').
+ * @returns {RegExp} The regular expression to match one or more letters.
+ */
+function multiLetters(type = 'g') {
+  return new RegExp('[a-zA-Z]+', type); // Matches one or more letters
+}
+
+exports.multiLetters = multiLetters;
+exports.oneLetter = oneLetter;

package/dist/legacy/libs/regex/getLetter.d.mts

@@ -0,0 +1,12 @@
+/**
+ * Matches exactly one letter (lowercase or uppercase).
+ * @param {string} [type='g'] - The flag for the regular expression (default is 'g').
+ * @returns {RegExp} The regular expression to match exactly one letter.
+ */
+export function oneLetter(type?: string): RegExp;
+/**
+ * Matches one or more letters (lowercase or uppercase).
+ * @param {string} [type='g'] - The flag for the regular expression (default is 'g').
+ * @returns {RegExp} The regular expression to match one or more letters.
+ */
+export function multiLetters(type?: string): RegExp;

package/dist/legacy/libs/regex/getLetter.mjs

@@ -0,0 +1,19 @@
+/**
+ * Matches exactly one letter (lowercase or uppercase).
+ * @param {string} [type='g'] - The flag for the regular expression (default is 'g').
+ * @returns {RegExp} The regular expression to match exactly one letter.
+ */
+function oneLetter(type = 'g') {
+    return new RegExp('^[a-zA-Z]+$', type); // Matches exactly one letter
+}
+/**
+ * Matches one or more letters (lowercase or uppercase).
+ * @param {string} [type='g'] - The flag for the regular expression (default is 'g').
+ * @returns {RegExp} The regular expression to match one or more letters.
+ */
+function multiLetters(type = 'g') {
+    return new RegExp('[a-zA-Z]+', type); // Matches one or more letters
+}
+export { oneLetter, // Matches exactly one letter
+multiLetters, // Matches one or more letters
+ };

package/dist/legacy/libs/replaceAsync.cjs

@@ -0,0 +1,32 @@
+'use strict';
+
+/**
+ * Asynchronously replaces matches in a string using a regex and an async function.
+ *
+ * @param {string} str - The input string to perform replacements on.
+ * @param {RegExp} regex - The regular expression to match substrings for replacement.
+ * @param {Function} asyncFn - An asynchronous function that returns a replacement for each match.
+ *                             It receives the same arguments as a standard `replace` callback.
+ * @returns {Promise<string>} The resulting string with all async replacements applied.
+ *
+ * @example
+ * await asyncReplace("Hello @user1 and @user2!", /@\w+/g, async (mention) => {
+ *   return await getUserNameFromMention(mention);
+ * });
+ */
+async function asyncReplace(str, regex, asyncFn) {
+  const promises = [];
+
+  // Collect promises
+  str.replace(regex, (match, ...args) => {
+    promises.push(asyncFn(match, ...args));
+    return match;
+  });
+
+  const data = await Promise.all(promises);
+
+  // Replace using the resolved data
+  return str.replace(regex, () => data.shift());
+}
+
+module.exports = asyncReplace;

package/dist/legacy/libs/replaceAsync.d.mts

@@ -0,0 +1,15 @@
+/**
+ * Asynchronously replaces matches in a string using a regex and an async function.
+ *
+ * @param {string} str - The input string to perform replacements on.
+ * @param {RegExp} regex - The regular expression to match substrings for replacement.
+ * @param {Function} asyncFn - An asynchronous function that returns a replacement for each match.
+ *                             It receives the same arguments as a standard `replace` callback.
+ * @returns {Promise<string>} The resulting string with all async replacements applied.
+ *
+ * @example
+ * await asyncReplace("Hello @user1 and @user2!", /@\w+/g, async (mention) => {
+ *   return await getUserNameFromMention(mention);
+ * });
+ */
+export default function asyncReplace(str: string, regex: RegExp, asyncFn: Function): Promise<string>;

package/dist/legacy/libs/replaceAsync.mjs

@@ -0,0 +1,25 @@
+/**
+ * Asynchronously replaces matches in a string using a regex and an async function.
+ *
+ * @param {string} str - The input string to perform replacements on.
+ * @param {RegExp} regex - The regular expression to match substrings for replacement.
+ * @param {Function} asyncFn - An asynchronous function that returns a replacement for each match.
+ *                             It receives the same arguments as a standard `replace` callback.
+ * @returns {Promise<string>} The resulting string with all async replacements applied.
+ *
+ * @example
+ * await asyncReplace("Hello @user1 and @user2!", /@\w+/g, async (mention) => {
+ *   return await getUserNameFromMention(mention);
+ * });
+ */
+export default async function asyncReplace(str, regex, asyncFn) {
+    const promises = [];
+    // Collect promises
+    str.replace(regex, (match, ...args) => {
+        promises.push(asyncFn(match, ...args));
+        return match;
+    });
+    const data = await Promise.all(promises);
+    // Replace using the resolved data
+    return str.replace(regex, () => data.shift());
+}

package/dist/legacy/libs/rule3.cjs

@@ -0,0 +1,58 @@
+'use strict';
+
+/**
+ * Rule of Three utility.
+ * Performs direct or inverse proportional calculation.
+ */
+const ruleOfThree = {
+  /**
+   * Returns the client-side version of the `execute` function as a string.
+   * Useful for embedding logic in the frontend.
+   *
+   * @returns {string} Function as string.
+   */
+  getClient: function () {
+    return ruleOfThree.execute.toString();
+  },
+
+  /**
+   * Executes a Rule of Three calculation.
+   *
+   * @param {number} val1 - The first reference value (numerator in direct proportion, denominator in inverse).
+   * @param {number} val2 - The second reference value (denominator in direct proportion, numerator in inverse).
+   * @param {number} val3 - The third value (numerator in direct proportion, denominator in inverse).
+   * @param {boolean} inverse - Whether the calculation should use inverse proportion (true for inverse, false for direct).
+   * @returns {number} The result of the Rule of Three operation.
+   *
+   * Rule of Three Formula (Direct Proportion):
+   *      val1 / val2 = val3 / result
+   *
+   * For Inverse Proportion:
+   *      val1 / val3 = val2 / result
+   *
+   * Visual Representation:
+   *
+   * For Direct Proportion:
+   *      val1      val2
+   *      -----  =  ------
+   *      val3      result
+   *
+   * For Inverse Proportion:
+   *      val1      val2
+   *      -----  =  ------
+   *      val3      result
+   *
+   * @example
+   * // Direct proportion:
+   * ruleOfThree.execute(2, 6, 3, false); // → 9
+   *
+   * @example
+   * // Inverse proportion:
+   * ruleOfThree.execute(2, 6, 3, true); // → 4
+   */
+  execute: function (val1, val2, val3, inverse) {
+    return inverse ? Number(val1 * val2) / val3 : Number(val3 * val2) / val1;
+  },
+};
+
+module.exports = ruleOfThree;

package/dist/legacy/libs/rule3.d.mts

@@ -0,0 +1,5 @@
+export default ruleOfThree;
+declare namespace ruleOfThree {
+    function getClient(): string;
+    function execute(val1: number, val2: number, val3: number, inverse: boolean): number;
+}

package/dist/legacy/libs/rule3.mjs

@@ -0,0 +1,54 @@
+/**
+ * Rule of Three utility.
+ * Performs direct or inverse proportional calculation.
+ */
+const ruleOfThree = {
+    /**
+     * Returns the client-side version of the `execute` function as a string.
+     * Useful for embedding logic in the frontend.
+     *
+     * @returns {string} Function as string.
+     */
+    getClient: function () {
+        return ruleOfThree.execute.toString();
+    },
+    /**
+     * Executes a Rule of Three calculation.
+     *
+     * @param {number} val1 - The first reference value (numerator in direct proportion, denominator in inverse).
+     * @param {number} val2 - The second reference value (denominator in direct proportion, numerator in inverse).
+     * @param {number} val3 - The third value (numerator in direct proportion, denominator in inverse).
+     * @param {boolean} inverse - Whether the calculation should use inverse proportion (true for inverse, false for direct).
+     * @returns {number} The result of the Rule of Three operation.
+     *
+     * Rule of Three Formula (Direct Proportion):
+     *      val1 / val2 = val3 / result
+     *
+     * For Inverse Proportion:
+     *      val1 / val3 = val2 / result
+     *
+     * Visual Representation:
+     *
+     * For Direct Proportion:
+     *      val1      val2
+     *      -----  =  ------
+     *      val3      result
+     *
+     * For Inverse Proportion:
+     *      val1      val2
+     *      -----  =  ------
+     *      val3      result
+     *
+     * @example
+     * // Direct proportion:
+     * ruleOfThree.execute(2, 6, 3, false); // → 9
+     *
+     * @example
+     * // Inverse proportion:
+     * ruleOfThree.execute(2, 6, 3, true); // → 4
+     */
+    execute: function (val1, val2, val3, inverse) {
+        return inverse ? Number(val1 * val2) / val3 : Number(val3 * val2) / val1;
+    },
+};
+export default ruleOfThree;

package/dist/legacy/libs/userLevel.cjs

@@ -0,0 +1,134 @@
+'use strict';
+
+/**
+ * Class to manage user level-up logic based on experience points.
+ */
+class TinyLevelUp {
+  /**
+   * Constructor
+   * @param {number} giveExp - Base experience value for random experience generation.
+   * @param {number} expLevel - Base experience needed to level up (per level).
+   */
+  constructor(giveExp, expLevel) {
+    this.giveExp = giveExp;
+    this.expLevel = expLevel;
+  }
+
+  /**
+   * Validates and adjusts the user's level based on their current experience.
+   * @param {Object} user - The user object containing experience and level properties.
+   * @returns {Object} The updated user object.
+   */
+  expValidator(user) {
+    let extraValue = 0;
+    const nextLevelExp = this.expLevel * user.level;
+
+    // Level Up
+    if (user.exp >= nextLevelExp) {
+      user.level++;
+      extraValue = user.exp - nextLevelExp;
+      user.exp = 0;
+
+      if (extraValue > 0) return this.give(user, extraValue, 'extra');
+    }
+
+    // Level Down
+    if (user.exp < 1 && user.level > 1) {
+      user.level--;
+      extraValue = Math.abs(user.exp);
+      user.exp = this.expLevel * user.level;
+
+      if (extraValue > 0) return this.remove(user, extraValue, 'extra');
+    }
+
+    return user;
+  }
+
+  /**
+   * Calculates the total experience based on the user's level.
+   * @param {Object} user - The user object containing experience and level properties.
+   * @returns {number} The total experience of the user.
+   */
+  getTotalExp(user) {
+    let totalExp = 0;
+    for (let p = 1; p <= user.level; p++) totalExp += this.expLevel * p;
+    totalExp += user.exp;
+    return totalExp;
+  }
+
+  /**
+   * Generates random experience points based on the configured multiplier.
+   * @param {number} multi - A multiplier for the generated experience.
+   * @returns {number} The generated experience points.
+   */
+  expGenerator(multi = 1) {
+    return Math.floor(Math.random() * this.giveExp) + 1 * multi;
+  }
+
+  /**
+   * Gets the experience points required to reach the next level.
+   * @param {Object} user - The user object containing the level.
+   * @returns {number} The experience required for the next level.
+   */
+  progress(user) {
+    return this.expLevel * user.level;
+  }
+
+  /**
+   * Gets the experience points required to reach the next level.
+   * @param {Object} user - The user object containing the level.
+   * @returns {number} The experience required for the next level.
+   */
+  getProgress(user) {
+    return this.expLevel * user.level;
+  }
+
+  /**
+   * Sets the experience value for the user, adjusting their level if necessary.
+   * @param {Object} user - The user object.
+   * @param {number} value - The new experience value to set.
+   * @returns {Object} The updated user object.
+   */
+  set(user, value) {
+    user.exp = value;
+    this.expValidator(user);
+    user.totalExp = this.getTotalExp(user);
+    return user;
+  }
+
+  /**
+   * Adds experience to the user, adjusting their level if necessary.
+   * @param {Object} user - The user object.
+   * @param {number} extraExp - Additional experience to be added.
+   * @param {string} type - Type of addition ('add' or 'extra').
+   * @param {number} multi - Multiplier for experience generation.
+   * @returns {Object} The updated user object.
+   */
+  give(user, extraExp = 0, type = 'add', multi = 1) {
+    if (type === 'add') user.exp += this.expGenerator(multi) + extraExp;
+    else if (type === 'extra') user.exp += extraExp;
+
+    this.expValidator(user);
+    user.totalExp = this.getTotalExp(user);
+    return user;
+  }
+
+  /**
+   * Removes experience from the user, adjusting their level if necessary.
+   * @param {Object} user - The user object.
+   * @param {number} extraExp - Experience to remove.
+   * @param {string} type - Type of removal ('add' or 'extra').
+   * @param {number} multi - Multiplier for experience generation.
+   * @returns {Object} The updated user object.
+   */
+  remove(user, extraExp = 0, type = 'add', multi = 1) {
+    if (type === 'add') user.exp -= this.expGenerator(multi) + extraExp;
+    else if (type === 'extra') user.exp -= extraExp;
+
+    this.expValidator(user);
+    user.totalExp = this.getTotalExp(user);
+    return user;
+  }
+}
+
+module.exports = TinyLevelUp;