tiny-essentials 1.0.0

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

@@ -0,0 +1,69 @@
+export default TinyLevelUp;
+/**
+ * Class to manage user level-up logic based on experience points.
+ */
+declare 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: number, expLevel: number);
+    giveExp: number;
+    expLevel: number;
+    /**
+     * 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: Object): Object;
+    /**
+     * 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: Object): number;
+    /**
+     * 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?: number): number;
+    /**
+     * 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: Object): number;
+    /**
+     * 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: Object): number;
+    /**
+     * 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: Object, value: number): Object;
+    /**
+     * 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: Object, extraExp?: number, type?: string, multi?: number): Object;
+    /**
+     * 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: Object, extraExp?: number, type?: string, multi?: number): Object;
+}

package/dist/legacy/libs/userLevel.mjs

@@ -0,0 +1,123 @@
+/**
+ * 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;
+    }
+}
+export default TinyLevelUp;

package/dist/legacy/momentjs/getAge.cjs

@@ -0,0 +1,28 @@
+'use strict';
+
+var moment = require('moment');
+
+/**
+ * Calculates the age based on the given date.
+ *
+ * @param {number|string} timeData - The birth date in a format accepted by moment.js (e.g., Unix timestamp, ISO 8601 string, etc.).
+ * @param {moment.Moment|null} [now=null] - The moment object representing the current date. Defaults to the current date and time if not provided.
+ * @returns {number|null} The age in years, or null if `timeData` is not provided.
+ */
+function getAge(timeData = 0, now = null) {
+  // Number
+  if (typeof timeData !== 'undefined') {
+    if (!now) now = moment();
+
+    const birthday = moment(timeData);
+    const age = Math.abs(birthday.diff(now, 'years'));
+    return age;
+  }
+
+  // Nope
+  else {
+    return null;
+  }
+}
+
+module.exports = getAge;

package/dist/legacy/momentjs/getAge.d.mts

@@ -0,0 +1,8 @@
+/**
+ * Calculates the age based on the given date.
+ *
+ * @param {number|string} timeData - The birth date in a format accepted by moment.js (e.g., Unix timestamp, ISO 8601 string, etc.).
+ * @param {moment.Moment|null} [now=null] - The moment object representing the current date. Defaults to the current date and time if not provided.
+ * @returns {number|null} The age in years, or null if `timeData` is not provided.
+ */
+export default function getAge(timeData?: number | string, now?: moment.Moment | null): number | null;

package/dist/legacy/momentjs/getAge.mjs

@@ -0,0 +1,22 @@
+import moment from 'moment';
+/**
+ * Calculates the age based on the given date.
+ *
+ * @param {number|string} timeData - The birth date in a format accepted by moment.js (e.g., Unix timestamp, ISO 8601 string, etc.).
+ * @param {moment.Moment|null} [now=null] - The moment object representing the current date. Defaults to the current date and time if not provided.
+ * @returns {number|null} The age in years, or null if `timeData` is not provided.
+ */
+export default function getAge(timeData = 0, now = null) {
+    // Number
+    if (typeof timeData !== 'undefined') {
+        if (!now)
+            now = moment();
+        const birthday = moment(timeData);
+        const age = Math.abs(birthday.diff(now, 'years'));
+        return age;
+    }
+    // Nope
+    else {
+        return null;
+    }
+}

package/dist/legacy/momentjs/index.cjs

@@ -0,0 +1,9 @@
+'use strict';
+
+var timeDuration = require('./timeDuration.cjs');
+var getAge = require('./getAge.cjs');
+
+
+
+exports.timeDuration = timeDuration;
+exports.getAge = getAge;

package/dist/legacy/momentjs/index.d.mts

@@ -0,0 +1,3 @@
+import timeDuration from './timeDuration.mjs';
+import getAge from './getAge.mjs';
+export { timeDuration, getAge };

package/dist/legacy/momentjs/index.mjs

@@ -0,0 +1,3 @@
+import timeDuration from './timeDuration.mjs';
+import getAge from './getAge.mjs';
+export { timeDuration, getAge };

package/dist/legacy/momentjs/timeDuration.cjs

@@ -0,0 +1,29 @@
+'use strict';
+
+var moment = require('moment');
+
+/**
+ * Calculates the time duration between the current time and a given time offset.
+ *
+ * @param {number} timeData - The time offset in milliseconds. Can be positive or negative.
+ * @param {string} [durationType='asSeconds'] - The type of duration to return. Default is `'asSeconds'`. Can be any valid moment.js duration type (e.g., `'asMilliseconds'`, `'asMinutes'`, `'asHours'`, etc.).
+ * @param {moment.Moment|null} [now=null] - The moment object representing the current date and time. Defaults to the current date and time if not provided.
+ * @returns {number|null} The calculated duration in the specified unit (default: seconds), or `null` if `timeData` is not provided.
+ */
+function timeDuration(timeData = 0, durationType = 'asSeconds', now = null) {
+  // Number
+  if (typeof timeData !== 'undefined') {
+    if (!now) now = moment();
+
+    var duration = moment.duration(now.clone().add(timeData, 'milliseconds').diff(now.clone()));
+    const result = duration[durationType]();
+
+    // Complete
+    return result;
+  }
+
+  // Nope
+  else return null;
+}
+
+module.exports = timeDuration;

package/dist/legacy/momentjs/timeDuration.d.mts

@@ -0,0 +1,9 @@
+/**
+ * Calculates the time duration between the current time and a given time offset.
+ *
+ * @param {number} timeData - The time offset in milliseconds. Can be positive or negative.
+ * @param {string} [durationType='asSeconds'] - The type of duration to return. Default is `'asSeconds'`. Can be any valid moment.js duration type (e.g., `'asMilliseconds'`, `'asMinutes'`, `'asHours'`, etc.).
+ * @param {moment.Moment|null} [now=null] - The moment object representing the current date and time. Defaults to the current date and time if not provided.
+ * @returns {number|null} The calculated duration in the specified unit (default: seconds), or `null` if `timeData` is not provided.
+ */
+export default function timeDuration(timeData?: number, durationType?: string, now?: moment.Moment | null): number | null;

package/dist/legacy/momentjs/timeDuration.mjs

@@ -0,0 +1,23 @@
+import moment from 'moment';
+/**
+ * Calculates the time duration between the current time and a given time offset.
+ *
+ * @param {number} timeData - The time offset in milliseconds. Can be positive or negative.
+ * @param {string} [durationType='asSeconds'] - The type of duration to return. Default is `'asSeconds'`. Can be any valid moment.js duration type (e.g., `'asMilliseconds'`, `'asMinutes'`, `'asHours'`, etc.).
+ * @param {moment.Moment|null} [now=null] - The moment object representing the current date and time. Defaults to the current date and time if not provided.
+ * @returns {number|null} The calculated duration in the specified unit (default: seconds), or `null` if `timeData` is not provided.
+ */
+export default function timeDuration(timeData = 0, durationType = 'asSeconds', now = null) {
+    // Number
+    if (typeof timeData !== 'undefined') {
+        if (!now)
+            now = moment();
+        var duration = moment.duration(now.clone().add(timeData, 'milliseconds').diff(now.clone()));
+        const result = duration[durationType]();
+        // Complete
+        return result;
+    }
+    // Nope
+    else
+        return null;
+}

package/dist/legacy/socket.io/antiFlood/index.cjs

@@ -0,0 +1,9 @@
+'use strict';
+
+var install = require('./install.cjs');
+var verify = require('./verify.cjs');
+
+
+
+exports.install = install;
+exports.verify = verify;

package/dist/legacy/socket.io/antiFlood/index.d.mts

@@ -0,0 +1,3 @@
+import verify from './verify.mjs';
+import install from './install.mjs';
+export { verify, install };

package/dist/legacy/socket.io/antiFlood/index.mjs

@@ -0,0 +1,3 @@
+import install from './install.mjs';
+import verify from './verify.mjs';
+export { verify, install };

package/dist/legacy/socket.io/antiFlood/install.cjs

@@ -0,0 +1,32 @@
+'use strict';
+
+var userIP = require('../../http/userIP.cjs');
+
+/**
+ * Installs the authorization middleware for socket connections.
+ *
+ * This middleware checks the user's IP address and allows or denies the socket connection based on whether
+ * the IP is in the block list or not.
+ *
+ * @param {Object} io - The Socket.IO server instance.
+ * @param {Object} ioCache - The cache object containing blocked IPs.
+ * @param {Array} ioCache.blocklick - The list of blocked IP addresses.
+ * @returns {void} This function does not return a value, it just sets the authorization logic for socket connections.
+ */
+function install(io, ioCache) {
+  io.set('authorization', function (socket, callback) {
+    // Get User IP
+    const ip = userIP(socket.handshake);
+
+    // Check if the IP is blocked
+    if (!Array.isArray(ioCache.blocklick) || ioCache.blocklick.indexOf(ip) < 0) {
+      // Allow the socket to connect
+      callback(null, true);
+    } else {
+      // Prevent the socket handshake with an error
+      callback('socket.io is not accepting connections from this page', false);
+    }
+  });
+}
+
+module.exports = install;

package/dist/legacy/socket.io/antiFlood/install.d.mts

@@ -0,0 +1,14 @@
+/**
+ * Installs the authorization middleware for socket connections.
+ *
+ * This middleware checks the user's IP address and allows or denies the socket connection based on whether
+ * the IP is in the block list or not.
+ *
+ * @param {Object} io - The Socket.IO server instance.
+ * @param {Object} ioCache - The cache object containing blocked IPs.
+ * @param {Array} ioCache.blocklick - The list of blocked IP addresses.
+ * @returns {void} This function does not return a value, it just sets the authorization logic for socket connections.
+ */
+export default function install(io: Object, ioCache: {
+    blocklick: any[];
+}): void;

package/dist/legacy/socket.io/antiFlood/install.mjs

@@ -0,0 +1,27 @@
+import userIp from '../../http/userIP.mjs';
+/**
+ * Installs the authorization middleware for socket connections.
+ *
+ * This middleware checks the user's IP address and allows or denies the socket connection based on whether
+ * the IP is in the block list or not.
+ *
+ * @param {Object} io - The Socket.IO server instance.
+ * @param {Object} ioCache - The cache object containing blocked IPs.
+ * @param {Array} ioCache.blocklick - The list of blocked IP addresses.
+ * @returns {void} This function does not return a value, it just sets the authorization logic for socket connections.
+ */
+export default function install(io, ioCache) {
+    io.set('authorization', function (socket, callback) {
+        // Get User IP
+        const ip = userIp(socket.handshake);
+        // Check if the IP is blocked
+        if (!Array.isArray(ioCache.blocklick) || ioCache.blocklick.indexOf(ip) < 0) {
+            // Allow the socket to connect
+            callback(null, true);
+        }
+        else {
+            // Prevent the socket handshake with an error
+            callback('socket.io is not accepting connections from this page', false);
+        }
+    });
+}

package/dist/legacy/socket.io/antiFlood/verify.cjs

@@ -0,0 +1,87 @@
+'use strict';
+
+var userIP = require('../../http/userIP.cjs');
+
+// Panel
+const floodPanel = {};
+
+/**
+ * Periodically decrements the timeout for each IP in the flood panel and removes expired entries.
+ * This is set to run every second.
+ */
+setInterval(function () {
+  // IP Cache
+  for (const item in floodPanel) {
+    floodPanel[item].timeout--;
+    if (floodPanel[item].timeout < 0) delete floodPanel[item];
+  }
+}, 1000);
+
+/**
+ * Verifies the IP address of a user socket for flooding attempts.
+ *
+ * This function checks how many times an IP has attempted to interact with the socket.
+ * If the attempts exceed a threshold, the IP is temporarily banned and disconnected.
+ *
+ * @param {Object} socket - The socket object representing the connection.
+ * @param {Object} ioCache - The cache object that holds the blocklist and flood panel data.
+ * @param {Array} ioCache.blocklick - The list of blocked IPs.
+ * @param {Object} floodPanel - The object tracking flooding attempts and timeouts for each IP.
+ * @returns {void} This function does not return anything, it modifies the floodPanel and blocklist.
+ */
+function verify(socket, ioCache) {
+  // Get User IP
+  const ip = userIP(socket.handshake);
+
+  /**
+   * Verifies the IP for flooding attempts and manages timeout and blocklist.
+   */
+  const verifyIP = function () {
+    // Create Item if it doesn't exist
+    if (!floodPanel[ip]) {
+      floodPanel[ip] = {
+        tries: 0,
+        timeout: 2,
+      };
+
+      // Remove Ban if any
+      const indexBan = ioCache.blocklick.indexOf(ip);
+      if (indexBan > -1) ioCache.blocklick.splice(indexBan, 1);
+    }
+
+    // Add Try for the current IP
+    floodPanel[ip].tries++;
+
+    // If tries exceed limit, block the IP
+    if (floodPanel[ip].tries > 1000) {
+      floodPanel[ip].timeout = 86400; // Set timeout to 24 hours
+      ioCache.blocklick.push(ip); // Add to blocklist
+
+      socket.disconnect(); // Disconnect the socket
+    }
+  };
+
+  // Create Blocklist if it doesn't exist
+  if (!Array.isArray(ioCache.blocklick)) {
+    ioCache.blocklick = [];
+  }
+
+  // Catch-all Event Listener
+  var onevent = socket.onevent;
+  socket.onevent = function (packet) {
+    var args = packet.data || [];
+    onevent.call(this, packet); // original call
+    packet.data = ['*'].concat(args);
+    onevent.call(this, packet); // additional call to catch-all
+  };
+
+  // Verify Action on All Events
+  socket.on('*', function () {
+    return verifyIP();
+  });
+
+  // First Verify IP
+  return verifyIP();
+}
+
+module.exports = verify;

package/dist/legacy/socket.io/antiFlood/verify.d.mts

@@ -0,0 +1,15 @@
+/**
+ * Verifies the IP address of a user socket for flooding attempts.
+ *
+ * This function checks how many times an IP has attempted to interact with the socket.
+ * If the attempts exceed a threshold, the IP is temporarily banned and disconnected.
+ *
+ * @param {Object} socket - The socket object representing the connection.
+ * @param {Object} ioCache - The cache object that holds the blocklist and flood panel data.
+ * @param {Array} ioCache.blocklick - The list of blocked IPs.
+ * @param {Object} floodPanel - The object tracking flooding attempts and timeouts for each IP.
+ * @returns {void} This function does not return anything, it modifies the floodPanel and blocklist.
+ */
+export default function verify(socket: Object, ioCache: {
+    blocklick: any[];
+}): void;

package/dist/legacy/socket.io/antiFlood/verify.mjs

@@ -0,0 +1,73 @@
+import userIp from '../../http/userIP.mjs';
+// Panel
+const floodPanel = {};
+/**
+ * Periodically decrements the timeout for each IP in the flood panel and removes expired entries.
+ * This is set to run every second.
+ */
+setInterval(function () {
+    // IP Cache
+    for (const item in floodPanel) {
+        floodPanel[item].timeout--;
+        if (floodPanel[item].timeout < 0)
+            delete floodPanel[item];
+    }
+}, 1000);
+/**
+ * Verifies the IP address of a user socket for flooding attempts.
+ *
+ * This function checks how many times an IP has attempted to interact with the socket.
+ * If the attempts exceed a threshold, the IP is temporarily banned and disconnected.
+ *
+ * @param {Object} socket - The socket object representing the connection.
+ * @param {Object} ioCache - The cache object that holds the blocklist and flood panel data.
+ * @param {Array} ioCache.blocklick - The list of blocked IPs.
+ * @param {Object} floodPanel - The object tracking flooding attempts and timeouts for each IP.
+ * @returns {void} This function does not return anything, it modifies the floodPanel and blocklist.
+ */
+export default function verify(socket, ioCache) {
+    // Get User IP
+    const ip = userIp(socket.handshake);
+    /**
+     * Verifies the IP for flooding attempts and manages timeout and blocklist.
+     */
+    const verifyIP = function () {
+        // Create Item if it doesn't exist
+        if (!floodPanel[ip]) {
+            floodPanel[ip] = {
+                tries: 0,
+                timeout: 2,
+            };
+            // Remove Ban if any
+            const indexBan = ioCache.blocklick.indexOf(ip);
+            if (indexBan > -1)
+                ioCache.blocklick.splice(indexBan, 1);
+        }
+        // Add Try for the current IP
+        floodPanel[ip].tries++;
+        // If tries exceed limit, block the IP
+        if (floodPanel[ip].tries > 1000) {
+            floodPanel[ip].timeout = 86400; // Set timeout to 24 hours
+            ioCache.blocklick.push(ip); // Add to blocklist
+            socket.disconnect(); // Disconnect the socket
+        }
+    };
+    // Create Blocklist if it doesn't exist
+    if (!Array.isArray(ioCache.blocklick)) {
+        ioCache.blocklick = [];
+    }
+    // Catch-all Event Listener
+    var onevent = socket.onevent;
+    socket.onevent = function (packet) {
+        var args = packet.data || [];
+        onevent.call(this, packet); // original call
+        packet.data = ['*'].concat(args);
+        onevent.call(this, packet); // additional call to catch-all
+    };
+    // Verify Action on All Events
+    socket.on('*', function () {
+        return verifyIP();
+    });
+    // First Verify IP
+    return verifyIP();
+}

package/dist/legacy/socket.io/cookie-session.cjs

@@ -0,0 +1,25 @@
+'use strict';
+
+/**
+ * Handles the cookie session for a socket connection by simulating an Express request and response.
+ * This function uses the provided session module to manage session data for the socket connection.
+ *
+ * @param {Object} socket - The socket object representing the connection.
+ * @param {Function} sessionModule - The session module function, typically used with Express, that handles session logic.
+ * @returns {Promise<Object>} A promise that resolves with the session object once the session is processed.
+ */
+function cookieSession(socket, sessionModule) {
+  return new Promise((resolve) => {
+    // Express Simulator
+    let req = {
+      connection: { encrypted: false },
+      headers: { cookie: socket.request.headers.cookie },
+    };
+    let res = { getHeader: () => {}, setHeader: () => {} };
+
+    // Session
+    return sessionModule(req, res, async () => resolve(req.session));
+  });
+}
+
+module.exports = cookieSession;

package/dist/legacy/socket.io/cookie-session.d.mts

@@ -0,0 +1,9 @@
+/**
+ * Handles the cookie session for a socket connection by simulating an Express request and response.
+ * This function uses the provided session module to manage session data for the socket connection.
+ *
+ * @param {Object} socket - The socket object representing the connection.
+ * @param {Function} sessionModule - The session module function, typically used with Express, that handles session logic.
+ * @returns {Promise<Object>} A promise that resolves with the session object once the session is processed.
+ */
+export default function cookieSession(socket: Object, sessionModule: Function): Promise<Object>;