tiny-essentials 1.0.0

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

@@ -0,0 +1,20 @@
+/**
+ * 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, 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));
+    });
+}

package/dist/legacy/socket.io/discord.cjs

@@ -0,0 +1,61 @@
+'use strict';
+
+var getUser = require('../firebase/discord/api/getUser.cjs');
+
+/**
+ * Handles the Discord OAuth2 authentication for a user, stores user data in an in-memory cache,
+ * and manages the user's socket connection and disconnection events.
+ *
+ * @param {Object} socket - The socket object representing the user's connection.
+ * @param {Object} ioCache - The shared cache that stores user data and connections.
+ * @param {string} token - The OAuth2 token used to fetch user data from Discord.
+ * @returns {Promise<Object>} A promise that resolves with the user data and updates the cache.
+ */
+function discord(socket, ioCache, token) {
+  return new Promise((resolve, reject) => {
+    // Get Discord oAuth
+    getUser(token)
+      .then((user) => {
+        // Create Users Cache
+        if (!ioCache.users) ioCache.users = {};
+        if (!ioCache.ids) ioCache.ids = {};
+        if (typeof ioCache.totalUsers !== 'number') ioCache.totalUsers = 0;
+
+        // User Data
+        if (!ioCache.users[user.id]) {
+          ioCache.users[user.id] = {
+            ids: {},
+          };
+
+          ioCache.ids[socket.id] = user.id;
+          ioCache.totalUsers++;
+        }
+
+        // Update Discord Data
+        ioCache.users[user.id].data = user;
+
+        // ID Data
+        ioCache.users[user.id].ids[socket.id] = { socket: socket };
+
+        // Disconnect
+        socket.on('disconnect', function () {
+          if (ioCache.users[user.id]) {
+            // IDs
+            delete ioCache.users[user.id].ids[socket.id];
+            delete ioCache.ids[socket.id];
+
+            if (Object.keys(ioCache.users[user.id].ids).length < 1) {
+              delete ioCache.users[user.id];
+              ioCache.totalUsers--;
+            }
+          }
+        });
+
+        // Complete
+        resolve(ioCache.users[user.id]);
+      })
+      .catch(reject);
+  });
+}
+
+module.exports = discord;

package/dist/legacy/socket.io/discord.d.mts

@@ -0,0 +1,10 @@
+/**
+ * Handles the Discord OAuth2 authentication for a user, stores user data in an in-memory cache,
+ * and manages the user's socket connection and disconnection events.
+ *
+ * @param {Object} socket - The socket object representing the user's connection.
+ * @param {Object} ioCache - The shared cache that stores user data and connections.
+ * @param {string} token - The OAuth2 token used to fetch user data from Discord.
+ * @returns {Promise<Object>} A promise that resolves with the user data and updates the cache.
+ */
+export default function discord(socket: Object, ioCache: Object, token: string): Promise<Object>;

package/dist/legacy/socket.io/discord.mjs

@@ -0,0 +1,52 @@
+import getUser from '../firebase/discord/api/getUser.mjs';
+/**
+ * Handles the Discord OAuth2 authentication for a user, stores user data in an in-memory cache,
+ * and manages the user's socket connection and disconnection events.
+ *
+ * @param {Object} socket - The socket object representing the user's connection.
+ * @param {Object} ioCache - The shared cache that stores user data and connections.
+ * @param {string} token - The OAuth2 token used to fetch user data from Discord.
+ * @returns {Promise<Object>} A promise that resolves with the user data and updates the cache.
+ */
+export default function discord(socket, ioCache, token) {
+    return new Promise((resolve, reject) => {
+        // Get Discord oAuth
+        getUser(token)
+            .then((user) => {
+            // Create Users Cache
+            if (!ioCache.users)
+                ioCache.users = {};
+            if (!ioCache.ids)
+                ioCache.ids = {};
+            if (typeof ioCache.totalUsers !== 'number')
+                ioCache.totalUsers = 0;
+            // User Data
+            if (!ioCache.users[user.id]) {
+                ioCache.users[user.id] = {
+                    ids: {},
+                };
+                ioCache.ids[socket.id] = user.id;
+                ioCache.totalUsers++;
+            }
+            // Update Discord Data
+            ioCache.users[user.id].data = user;
+            // ID Data
+            ioCache.users[user.id].ids[socket.id] = { socket: socket };
+            // Disconnect
+            socket.on('disconnect', function () {
+                if (ioCache.users[user.id]) {
+                    // IDs
+                    delete ioCache.users[user.id].ids[socket.id];
+                    delete ioCache.ids[socket.id];
+                    if (Object.keys(ioCache.users[user.id].ids).length < 1) {
+                        delete ioCache.users[user.id];
+                        ioCache.totalUsers--;
+                    }
+                }
+            });
+            // Complete
+            resolve(ioCache.users[user.id]);
+        })
+            .catch(reject);
+    });
+}

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

@@ -0,0 +1,13 @@
+'use strict';
+
+var index = require('./antiFlood/index.cjs');
+var discord = require('./discord.cjs');
+var cookieSession = require('./cookie-session.cjs');
+
+const socketIo = {
+  antiFlood: index,
+  'cookie-session': cookieSession,
+  discord,
+};
+
+module.exports = socketIo;

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

@@ -0,0 +1,9 @@
+export default socketIo;
+declare const socketIo: {
+    antiFlood: typeof antiFlood;
+    'cookie-session': typeof cookieSession;
+    discord: typeof discord;
+};
+import * as antiFlood from './antiFlood/index.mjs';
+import cookieSession from './cookie-session.mjs';
+import discord from './discord.mjs';

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

@@ -0,0 +1,9 @@
+import * as antiFlood from './antiFlood/index.mjs';
+import discord from './discord.mjs';
+import cookieSession from './cookie-session.mjs';
+const socketIo = {
+    antiFlood,
+    'cookie-session': cookieSession,
+    discord,
+};
+export default socketIo;

package/dist/v1/basics/array.cjs

@@ -0,0 +1,31 @@
+'use strict';
+
+// https://stackoverflow.com/questions/2450954/how-to-randomize-shuffle-a-javascript-array
+
+/**
+ * Randomly shuffles the elements of an array in place using the Fisher–Yates algorithm.
+ *
+ * This implementation ensures a uniform distribution of permutations.
+ * Original algorithm source: StackOverflow (link above).
+ *
+ * @param {string[]} items - The array to shuffle.
+ * @returns {string[]} The same array instance, now shuffled in place.
+ */
+function shuffleArray(items) {
+  let currentIndex = items.length,
+    randomIndex;
+
+  // While there remain elements to shuffle...
+  while (currentIndex !== 0) {
+    // Pick a remaining element...
+    randomIndex = Math.floor(Math.random() * currentIndex);
+    currentIndex--;
+
+    // And swap it with the current element.
+    [items[currentIndex], items[randomIndex]] = [items[randomIndex], items[currentIndex]];
+  }
+
+  return items;
+}
+
+exports.shuffleArray = shuffleArray;

package/dist/v1/basics/array.d.mts

@@ -0,0 +1,10 @@
+/**
+ * Randomly shuffles the elements of an array in place using the Fisher–Yates algorithm.
+ *
+ * This implementation ensures a uniform distribution of permutations.
+ * Original algorithm source: StackOverflow (link above).
+ *
+ * @param {string[]} items - The array to shuffle.
+ * @returns {string[]} The same array instance, now shuffled in place.
+ */
+export function shuffleArray(items: string[]): string[];

package/dist/v1/basics/array.mjs

@@ -0,0 +1,22 @@
+// https://stackoverflow.com/questions/2450954/how-to-randomize-shuffle-a-javascript-array
+/**
+ * Randomly shuffles the elements of an array in place using the Fisher–Yates algorithm.
+ *
+ * This implementation ensures a uniform distribution of permutations.
+ * Original algorithm source: StackOverflow (link above).
+ *
+ * @param {string[]} items - The array to shuffle.
+ * @returns {string[]} The same array instance, now shuffled in place.
+ */
+export function shuffleArray(items) {
+    let currentIndex = items.length, randomIndex;
+    // While there remain elements to shuffle...
+    while (currentIndex !== 0) {
+        // Pick a remaining element...
+        randomIndex = Math.floor(Math.random() * currentIndex);
+        currentIndex--;
+        // And swap it with the current element.
+        [items[currentIndex], items[randomIndex]] = [items[randomIndex], items[currentIndex]];
+    }
+    return items;
+}

package/dist/v1/basics/clock.cjs

@@ -0,0 +1,187 @@
+'use strict';
+
+/**
+ * Calculates the time duration between the current time and a given time offset.
+ *
+ * @param {Date} timeData - The target time as a Date object.
+ * @param {string} [durationType='asSeconds'] - The type of duration to return. Can be 'asMilliseconds', 'asSeconds', 'asMinutes', 'asHours', 'asDays'.
+ * @param {Date|null} [now=null] - The current time as a Date object. Defaults to the current date and time if not provided.
+ * @returns {number|null} The calculated duration in the specified unit, or `null` if `timeData` is not provided.
+ */
+function getTimeDuration(timeData = new Date(), durationType = 'asSeconds', now = null) {
+  if (timeData instanceof Date) {
+    const currentTime = now instanceof Date ? now : new Date();
+    const diffMs = timeData - currentTime;
+
+    switch (durationType) {
+      case 'asMilliseconds':
+        return diffMs;
+      case 'asSeconds':
+        return diffMs / 1000;
+      case 'asMinutes':
+        return diffMs / (1000 * 60);
+      case 'asHours':
+        return diffMs / (1000 * 60 * 60);
+      case 'asDays':
+        return diffMs / (1000 * 60 * 60 * 24);
+      default:
+        return diffMs / 1000; // default to seconds
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Formats a custom timer string based on total seconds and a detail level.
+ * Includes proper reallocation of lower units into higher ones, ensuring consistent hierarchy.
+ *
+ * @param {number} totalSeconds - The total amount of seconds to convert.
+ * @param {'seconds'|'minutes'|'hours'|'days'|'months'|'years'} level - The highest level to calculate and display.
+ * @param {string} [format='{time}'] - Output template with placeholders like {years}, {months}, {days}, {hours}, {minutes}, {seconds}, {time}, {total}.
+ * @returns {string} The formatted timer string.
+ */
+function formatCustomTimer(totalSeconds, level = 'seconds', format = '{time}') {
+  totalSeconds = Math.max(0, Math.floor(totalSeconds));
+
+  const levels = ['seconds', 'minutes', 'hours', 'days', 'months', 'years'];
+  const index = levels.indexOf(level);
+
+  const include = {
+    years: index >= 5,
+    months: index >= 4,
+    days: index >= 3,
+    hours: index >= 2,
+    minutes: index >= 1,
+    seconds: index >= 0,
+  };
+
+  const parts = {
+    years: include.years ? 0 : NaN,
+    months: include.months ? 0 : NaN,
+    days: include.days ? 0 : NaN,
+    hours: include.hours ? 0 : NaN,
+    minutes: include.minutes ? 0 : NaN,
+    seconds: include.seconds ? 0 : NaN,
+    total: NaN,
+  };
+
+  let remaining = totalSeconds;
+
+  if (include.years || include.months || include.days) {
+    const baseDate = new Date(1980, 0, 1);
+    const targetDate = new Date(baseDate.getTime() + remaining * 1000);
+    const workingDate = new Date(baseDate);
+
+    // Years
+    if (include.years) {
+      while (
+        new Date(workingDate.getFullYear() + 1, workingDate.getMonth(), workingDate.getDate()) <=
+        targetDate
+      ) {
+        workingDate.setFullYear(workingDate.getFullYear() + 1);
+        parts.years++;
+      }
+    }
+
+    // Months
+    if (include.months) {
+      while (
+        new Date(workingDate.getFullYear(), workingDate.getMonth() + 1, workingDate.getDate()) <=
+        targetDate
+      ) {
+        workingDate.setMonth(workingDate.getMonth() + 1);
+        parts.months++;
+      }
+    }
+
+    // Days
+    if (include.days) {
+      while (
+        new Date(workingDate.getFullYear(), workingDate.getMonth(), workingDate.getDate() + 1) <=
+        targetDate
+      ) {
+        workingDate.setDate(workingDate.getDate() + 1);
+        parts.days++;
+      }
+    }
+
+    remaining = Math.floor((targetDate - workingDate) / 1000);
+  }
+
+  if (include.hours) {
+    parts.hours = Math.floor(remaining / 3600);
+    remaining %= 3600;
+  }
+
+  if (include.minutes) {
+    parts.minutes = Math.floor(remaining / 60);
+    remaining %= 60;
+  }
+
+  if (include.seconds) {
+    parts.seconds = remaining;
+  }
+
+  // Calculate total
+  const totalMap = {
+    seconds: include.seconds ? totalSeconds : NaN,
+    minutes: include.minutes ? totalSeconds / 60 : NaN,
+    hours: include.hours ? totalSeconds / 3600 : NaN,
+    days: include.days ? totalSeconds / 86400 : NaN,
+    months: include.months ? parts.years * 12 + parts.months + (parts.days || 0) / 30 : NaN,
+    years: include.years ? parts.years + (parts.months || 0) / 12 + (parts.days || 0) / 365 : NaN,
+  };
+
+  parts.total = +(totalMap[level] || 0).toFixed(2).replace(/\.00$/, '');
+
+  const pad = (n) => (isNaN(n) ? 'NaN' : String(n).padStart(2, '0'));
+
+  const timeString = [
+    include.hours ? pad(parts.hours) : null,
+    include.minutes ? pad(parts.minutes) : null,
+    include.seconds ? pad(parts.seconds) : null,
+  ]
+    .filter((v) => v !== null)
+    .join(':');
+
+  return format
+    .replace(/\{years\}/g, parts.years)
+    .replace(/\{months\}/g, parts.months)
+    .replace(/\{days\}/g, parts.days)
+    .replace(/\{hours\}/g, pad(parts.hours))
+    .replace(/\{minutes\}/g, pad(parts.minutes))
+    .replace(/\{seconds\}/g, pad(parts.seconds))
+    .replace(/\{time\}/g, timeString)
+    .replace(/\{total\}/g, parts.total)
+    .trim();
+}
+
+/**
+ * Formats a duration (in seconds) into a timer string showing only hours, minutes, and seconds.
+ *
+ * Example output: "05:32:10"
+ *
+ * @param {number} seconds - The total number of seconds to format.
+ * @returns {string} The formatted timer string in "HH:MM:SS" format.
+ */
+function formatTimer(seconds) {
+  return formatCustomTimer(seconds, 'hours', '{hours}:{minutes}:{seconds}');
+}
+
+/**
+ * Formats a duration (in seconds) into a timer string including days, hours, minutes, and seconds.
+ *
+ * Example output: "2d 05:32:10"
+ *
+ * @param {number} seconds - The total number of seconds to format.
+ * @returns {string} The formatted timer string in "Xd HH:MM:SS" format.
+ */
+function formatDayTimer(seconds) {
+  return formatCustomTimer(seconds, 'days', '{days}d {hours}:{minutes}:{seconds}');
+}
+
+exports.formatCustomTimer = formatCustomTimer;
+exports.formatDayTimer = formatDayTimer;
+exports.formatTimer = formatTimer;
+exports.getTimeDuration = getTimeDuration;

package/dist/v1/basics/clock.d.mts

@@ -0,0 +1,37 @@
+/**
+ * Calculates the time duration between the current time and a given time offset.
+ *
+ * @param {Date} timeData - The target time as a Date object.
+ * @param {string} [durationType='asSeconds'] - The type of duration to return. Can be 'asMilliseconds', 'asSeconds', 'asMinutes', 'asHours', 'asDays'.
+ * @param {Date|null} [now=null] - The current time as a Date object. Defaults to the current date and time if not provided.
+ * @returns {number|null} The calculated duration in the specified unit, or `null` if `timeData` is not provided.
+ */
+export function getTimeDuration(timeData?: Date, durationType?: string, now?: Date | null): number | null;
+/**
+ * Formats a custom timer string based on total seconds and a detail level.
+ * Includes proper reallocation of lower units into higher ones, ensuring consistent hierarchy.
+ *
+ * @param {number} totalSeconds - The total amount of seconds to convert.
+ * @param {'seconds'|'minutes'|'hours'|'days'|'months'|'years'} level - The highest level to calculate and display.
+ * @param {string} [format='{time}'] - Output template with placeholders like {years}, {months}, {days}, {hours}, {minutes}, {seconds}, {time}, {total}.
+ * @returns {string} The formatted timer string.
+ */
+export function formatCustomTimer(totalSeconds: number, level?: "seconds" | "minutes" | "hours" | "days" | "months" | "years", format?: string): string;
+/**
+ * Formats a duration (in seconds) into a timer string showing only hours, minutes, and seconds.
+ *
+ * Example output: "05:32:10"
+ *
+ * @param {number} seconds - The total number of seconds to format.
+ * @returns {string} The formatted timer string in "HH:MM:SS" format.
+ */
+export function formatTimer(seconds: number): string;
+/**
+ * Formats a duration (in seconds) into a timer string including days, hours, minutes, and seconds.
+ *
+ * Example output: "2d 05:32:10"
+ *
+ * @param {number} seconds - The total number of seconds to format.
+ * @returns {string} The formatted timer string in "Xd HH:MM:SS" format.
+ */
+export function formatDayTimer(seconds: number): string;

package/dist/v1/basics/clock.mjs

@@ -0,0 +1,152 @@
+/**
+ * Calculates the time duration between the current time and a given time offset.
+ *
+ * @param {Date} timeData - The target time as a Date object.
+ * @param {string} [durationType='asSeconds'] - The type of duration to return. Can be 'asMilliseconds', 'asSeconds', 'asMinutes', 'asHours', 'asDays'.
+ * @param {Date|null} [now=null] - The current time as a Date object. Defaults to the current date and time if not provided.
+ * @returns {number|null} The calculated duration in the specified unit, or `null` if `timeData` is not provided.
+ */
+export function getTimeDuration(timeData = new Date(), durationType = 'asSeconds', now = null) {
+    if (timeData instanceof Date) {
+        const currentTime = now instanceof Date ? now : new Date();
+        const diffMs = timeData - currentTime;
+        switch (durationType) {
+            case 'asMilliseconds':
+                return diffMs;
+            case 'asSeconds':
+                return diffMs / 1000;
+            case 'asMinutes':
+                return diffMs / (1000 * 60);
+            case 'asHours':
+                return diffMs / (1000 * 60 * 60);
+            case 'asDays':
+                return diffMs / (1000 * 60 * 60 * 24);
+            default:
+                return diffMs / 1000; // default to seconds
+        }
+    }
+    return null;
+}
+/**
+ * Formats a custom timer string based on total seconds and a detail level.
+ * Includes proper reallocation of lower units into higher ones, ensuring consistent hierarchy.
+ *
+ * @param {number} totalSeconds - The total amount of seconds to convert.
+ * @param {'seconds'|'minutes'|'hours'|'days'|'months'|'years'} level - The highest level to calculate and display.
+ * @param {string} [format='{time}'] - Output template with placeholders like {years}, {months}, {days}, {hours}, {minutes}, {seconds}, {time}, {total}.
+ * @returns {string} The formatted timer string.
+ */
+export function formatCustomTimer(totalSeconds, level = 'seconds', format = '{time}') {
+    totalSeconds = Math.max(0, Math.floor(totalSeconds));
+    const levels = ['seconds', 'minutes', 'hours', 'days', 'months', 'years'];
+    const index = levels.indexOf(level);
+    const include = {
+        years: index >= 5,
+        months: index >= 4,
+        days: index >= 3,
+        hours: index >= 2,
+        minutes: index >= 1,
+        seconds: index >= 0,
+    };
+    const parts = {
+        years: include.years ? 0 : NaN,
+        months: include.months ? 0 : NaN,
+        days: include.days ? 0 : NaN,
+        hours: include.hours ? 0 : NaN,
+        minutes: include.minutes ? 0 : NaN,
+        seconds: include.seconds ? 0 : NaN,
+        total: NaN,
+    };
+    let remaining = totalSeconds;
+    if (include.years || include.months || include.days) {
+        const baseDate = new Date(1980, 0, 1);
+        const targetDate = new Date(baseDate.getTime() + remaining * 1000);
+        const workingDate = new Date(baseDate);
+        // Years
+        if (include.years) {
+            while (new Date(workingDate.getFullYear() + 1, workingDate.getMonth(), workingDate.getDate()) <=
+                targetDate) {
+                workingDate.setFullYear(workingDate.getFullYear() + 1);
+                parts.years++;
+            }
+        }
+        // Months
+        if (include.months) {
+            while (new Date(workingDate.getFullYear(), workingDate.getMonth() + 1, workingDate.getDate()) <=
+                targetDate) {
+                workingDate.setMonth(workingDate.getMonth() + 1);
+                parts.months++;
+            }
+        }
+        // Days
+        if (include.days) {
+            while (new Date(workingDate.getFullYear(), workingDate.getMonth(), workingDate.getDate() + 1) <=
+                targetDate) {
+                workingDate.setDate(workingDate.getDate() + 1);
+                parts.days++;
+            }
+        }
+        remaining = Math.floor((targetDate - workingDate) / 1000);
+    }
+    if (include.hours) {
+        parts.hours = Math.floor(remaining / 3600);
+        remaining %= 3600;
+    }
+    if (include.minutes) {
+        parts.minutes = Math.floor(remaining / 60);
+        remaining %= 60;
+    }
+    if (include.seconds) {
+        parts.seconds = remaining;
+    }
+    // Calculate total
+    const totalMap = {
+        seconds: include.seconds ? totalSeconds : NaN,
+        minutes: include.minutes ? totalSeconds / 60 : NaN,
+        hours: include.hours ? totalSeconds / 3600 : NaN,
+        days: include.days ? totalSeconds / 86400 : NaN,
+        months: include.months ? parts.years * 12 + parts.months + (parts.days || 0) / 30 : NaN,
+        years: include.years ? parts.years + (parts.months || 0) / 12 + (parts.days || 0) / 365 : NaN,
+    };
+    parts.total = +(totalMap[level] || 0).toFixed(2).replace(/\.00$/, '');
+    const pad = (n) => (isNaN(n) ? 'NaN' : String(n).padStart(2, '0'));
+    const timeString = [
+        include.hours ? pad(parts.hours) : null,
+        include.minutes ? pad(parts.minutes) : null,
+        include.seconds ? pad(parts.seconds) : null,
+    ]
+        .filter((v) => v !== null)
+        .join(':');
+    return format
+        .replace(/\{years\}/g, parts.years)
+        .replace(/\{months\}/g, parts.months)
+        .replace(/\{days\}/g, parts.days)
+        .replace(/\{hours\}/g, pad(parts.hours))
+        .replace(/\{minutes\}/g, pad(parts.minutes))
+        .replace(/\{seconds\}/g, pad(parts.seconds))
+        .replace(/\{time\}/g, timeString)
+        .replace(/\{total\}/g, parts.total)
+        .trim();
+}
+/**
+ * Formats a duration (in seconds) into a timer string showing only hours, minutes, and seconds.
+ *
+ * Example output: "05:32:10"
+ *
+ * @param {number} seconds - The total number of seconds to format.
+ * @returns {string} The formatted timer string in "HH:MM:SS" format.
+ */
+export function formatTimer(seconds) {
+    return formatCustomTimer(seconds, 'hours', '{hours}:{minutes}:{seconds}');
+}
+/**
+ * Formats a duration (in seconds) into a timer string including days, hours, minutes, and seconds.
+ *
+ * Example output: "2d 05:32:10"
+ *
+ * @param {number} seconds - The total number of seconds to format.
+ * @returns {string} The formatted timer string in "Xd HH:MM:SS" format.
+ */
+export function formatDayTimer(seconds) {
+    return formatCustomTimer(seconds, 'days', '{days}d {hours}:{minutes}:{seconds}');
+}

package/dist/v1/basics/objFilter.cjs

@@ -0,0 +1,55 @@
+'use strict';
+
+/**
+ * Checks the type of a given object or returns its type as a string.
+ *
+ * @param {*} obj - The object to check or identify.
+ * @param {string} [type] - Optional. If provided, checks whether the object matches this type (e.g., "object", "array", "string").
+ * @returns {boolean|string|null} - Returns `true` if the type matches, `false` if not,
+ *                                   the type string if no type is provided, or `null` if the object is `undefined`.
+ *
+ * @example
+ * objType([], 'array'); // true
+ * objType({}, 'object'); // true
+ * objType('hello'); // "string"
+ * objType(undefined); // null
+ */
+function objType(obj, type) {
+  // Is Defined
+  if (typeof obj !== 'undefined') {
+    // Get Obj Type
+    const result = Object.prototype.toString.call(obj).toLowerCase();
+    // Check Obj Type
+    if (typeof type === 'string') {
+      if (result === `[object ${type}]`) return true;
+      return false;
+    }
+    // Send Result
+    return result.substring(8, result.length - 1);
+  }
+  // Nope
+  return null;
+}
+
+/**
+ * Counts the number of elements in an array or the number of properties in an object.
+ *
+ * @param {*} obj - The array or object to count.
+ * @returns {number} - The count of items (array elements or object keys), or `0` if the input is neither an array nor an object.
+ *
+ * @example
+ * countObj([1, 2, 3]); // 3
+ * countObj({ a: 1, b: 2 }); // 2
+ * countObj('not an object'); // 0
+ */
+function countObj(obj) {
+  // Is Array
+  if (Array.isArray(obj)) return obj.length;
+  // Object
+  if (objType(obj, 'object')) return Object.keys(obj).length;
+  // Nothing
+  return 0;
+}
+
+exports.countObj = countObj;
+exports.objType = objType;