tiny-essentials 1.0.0

package/dist/legacy/firebase/database/saveAsync.mjs

@@ -0,0 +1,147 @@
+/**
+ * Class representing an asynchronous save system with callback support.
+ *
+ * This class is designed to handle database operations asynchronously and supports
+ * adding multiple operations to a queue, as well as running callbacks after each action.
+ *
+ * @class SaveAsync
+ */
+class SaveAsync {
+    /**
+     * Creates an instance of SaveAsync.
+     *
+     * @param {object} db - The database reference to interact with (e.g., Firebase or other DB).
+     */
+    constructor(db) {
+        this.db = db;
+        this.list = [];
+        this.callbacks = {};
+        this.using = false;
+    }
+    /**
+     * Registers a callback to be run when a specific action type is executed.
+     *
+     * @param {string} where - The action type (e.g., "set", "push", etc.).
+     * @param {Function} callback - The callback function to run when the action is performed.
+     * @returns {boolean} Returns `true` if the callback is successfully registered.
+     */
+    on(where, callback) {
+        if (!Array.isArray(this.callbacks[where]))
+            this.callbacks[where] = [];
+        this.callbacks[where].push(callback);
+        return true;
+    }
+    /**
+     * Runs all callbacks associated with a specific action type.
+     *
+     * @param {string} type - The action type (e.g., "set", "push", etc.).
+     * @param {any} data - The data passed to the callback(s).
+     * @param {string} [where] - The location (optional) where the action was performed.
+     */
+    _runCallbacks(type, data, where) {
+        if (Array.isArray(this.callbacks[type]))
+            for (const item in this.callbacks[type])
+                if (typeof this.callbacks[type][item] === 'function')
+                    this.callbacks[type][item](data, where);
+    }
+    /**
+     * Processes the queued actions and executes them one by one.
+     *
+     * Each action in the queue is processed asynchronously. Once one action completes,
+     * the next action in the queue is triggered.
+     */
+    action() {
+        // Insert
+        if (this.list.length > 0) {
+            // Get Item
+            const post = this.list.shift();
+            const tinyThis = this;
+            // Try
+            try {
+                if (typeof post.where !== 'string') {
+                    if (post.data) {
+                        this.db[post.type](post.data)
+                            .then(() => {
+                            this._runCallbacks(post.type, post.data);
+                            tinyThis.action();
+                        })
+                            .catch((err) => {
+                            console.error(err);
+                        });
+                    }
+                    else {
+                        this.db[post.type]()
+                            .then(() => {
+                            this._runCallbacks(post.type);
+                            tinyThis.action();
+                        })
+                            .catch((err) => {
+                            console.error(err);
+                        });
+                    }
+                }
+                else {
+                    if (post.data) {
+                        this.db
+                            .child(post.where)[post.type](post.data)
+                            .then(() => {
+                            this._runCallbacks(post.type, post.data, post.where);
+                            tinyThis.action();
+                        })
+                            .catch((err) => {
+                            console.error(err);
+                        });
+                    }
+                    else {
+                        this.db
+                            .child(post.where)[post.type]()
+                            .then(() => {
+                            this._runCallbacks(post.type, null, post.where);
+                            tinyThis.action();
+                        })
+                            .catch((err) => {
+                            console.error(err);
+                        });
+                    }
+                }
+            }
+            catch (err) {
+                // Error
+                console.error(err);
+            }
+        }
+        // Nope
+        else
+            this.using = false;
+    }
+    /**
+     * Inserts a new action into the queue.
+     *
+     * The action will be executed when the system is ready (i.e., when the queue is not in use).
+     *
+     * @param {object} [data={}] - The data to be saved (optional).
+     * @param {string} [type='set'] - The type of the database action (e.g., 'set', 'push', etc.).
+     * @param {string|null} [where=null] - The location where the data should be stored (optional).
+     */
+    insert(data = {}, type = 'set', where = null) {
+        // Insert
+        if (data !== null) {
+            if (where !== null)
+                this.list.push({ where: String(where), data: data, type: type });
+            else
+                this.list.push({ data: data, type: type });
+        }
+        else {
+            if (where !== null)
+                this.list.push({ where: String(where), type: type });
+            else
+                this.list.push({ type: type });
+        }
+        if (!this.using) {
+            this.using = true;
+            this.action();
+        }
+    }
+}
+// Module export
+export default SaveAsync;

package/dist/legacy/firebase/databaseEscape.cjs

@@ -0,0 +1,42 @@
+'use strict';
+
+var escape = require('./escape.cjs');
+
+/**
+ * Escapes a given string or number for use in Firebase database paths, with an option to preserve the path structure.
+ *
+ * This function encodes the input string or number using a custom encoding defined in the `firebaseEscape.encode()` method.
+ * If the `keepPath` flag is set to `true`, the function will encode each segment of the path individually.
+ *
+ * @param {string|number} text - The text or number to be escaped.
+ * @param {boolean} [keepPath=false] - Whether to preserve the path structure (encode each path segment separately).
+ * @returns {string|null} The escaped string or null if the input is neither a string nor a number.
+ */
+function databaseEscape(text, keepPath = false) {
+  // Check if the input is a string or number
+  if (typeof text === 'string' || typeof text === 'number') {
+    // Convert the value to a string if it's a number
+    let new_value = text;
+    if (typeof new_value === 'number') new_value = String(new_value);
+
+    // Normal escape (do not preserve path)
+    if (!keepPath) new_value = escape.encode(new_value);
+    // Escape path segments individually (preserve path structure)
+    else {
+      // Split path into segments
+      new_value = new_value.split('/');
+      for (const item in new_value) new_value[item] = escape.encode(new_value[item]);
+
+      // Join the segments back into a single string
+      new_value = new_value.join('/');
+    }
+
+    // Return the escaped value
+    return new_value;
+  }
+
+  // Return null if the input is neither a string nor a number
+  else return null;
+}
+
+module.exports = databaseEscape;

package/dist/legacy/firebase/databaseEscape.d.mts

@@ -0,0 +1,11 @@
+/**
+ * Escapes a given string or number for use in Firebase database paths, with an option to preserve the path structure.
+ *
+ * This function encodes the input string or number using a custom encoding defined in the `firebaseEscape.encode()` method.
+ * If the `keepPath` flag is set to `true`, the function will encode each segment of the path individually.
+ *
+ * @param {string|number} text - The text or number to be escaped.
+ * @param {boolean} [keepPath=false] - Whether to preserve the path structure (encode each path segment separately).
+ * @returns {string|null} The escaped string or null if the input is neither a string nor a number.
+ */
+export default function databaseEscape(text: string | number, keepPath?: boolean): string | null;

package/dist/legacy/firebase/databaseEscape.mjs

@@ -0,0 +1,37 @@
+import * as firebaseEscape from './escape.mjs';
+/**
+ * Escapes a given string or number for use in Firebase database paths, with an option to preserve the path structure.
+ *
+ * This function encodes the input string or number using a custom encoding defined in the `firebaseEscape.encode()` method.
+ * If the `keepPath` flag is set to `true`, the function will encode each segment of the path individually.
+ *
+ * @param {string|number} text - The text or number to be escaped.
+ * @param {boolean} [keepPath=false] - Whether to preserve the path structure (encode each path segment separately).
+ * @returns {string|null} The escaped string or null if the input is neither a string nor a number.
+ */
+export default function databaseEscape(text, keepPath = false) {
+    // Check if the input is a string or number
+    if (typeof text === 'string' || typeof text === 'number') {
+        // Convert the value to a string if it's a number
+        let new_value = text;
+        if (typeof new_value === 'number')
+            new_value = String(new_value);
+        // Normal escape (do not preserve path)
+        if (!keepPath)
+            new_value = firebaseEscape.encode(new_value);
+        // Escape path segments individually (preserve path structure)
+        else {
+            // Split path into segments
+            new_value = new_value.split('/');
+            for (const item in new_value)
+                new_value[item] = firebaseEscape.encode(new_value[item]);
+            // Join the segments back into a single string
+            new_value = new_value.join('/');
+        }
+        // Return the escaped value
+        return new_value;
+    }
+    // Return null if the input is neither a string nor a number
+    else
+        return null;
+}

package/dist/legacy/firebase/databaseLogger.cjs

@@ -0,0 +1,258 @@
+'use strict';
+
+var objType = require('../get/objType.cjs');
+var moment = require('moment-timezone');
+var getDBData = require('./getDBData.cjs');
+
+// DB
+const tinyCache = {};
+let lastUpdate = { number: null, moment: null };
+let cacheLimit = 2000;
+
+// Action
+// Error To JSON
+if (!('toJSON' in Error.prototype)) {
+  Object.defineProperty(Error.prototype, 'toJSON', {
+    value: function () {
+      let alt = {};
+
+      Object.getOwnPropertyNames(this).forEach(function (key) {
+        alt[key] = this[key];
+      }, this);
+
+      return alt;
+    },
+    configurable: true,
+    writable: true,
+  });
+}
+
+/**
+ * Handles various logging actions (log, error, info, warn) and stores them in the database.
+ * Logs data are stored with a timestamp and are counted by type (log, error, info, warn).
+ * When the log count exceeds the specified cache limit, the database is cleared and reset.
+ *
+ * @param {string} where - The location or context where the log is coming from.
+ * @param {string} type - The type of log (log, error, info, or warn).
+ * @param {Array} args - The arguments to log (can include strings, numbers, objects, arrays, or errors).
+ * @returns {Promise<void>} Resolves once the log is stored in the database.
+ */
+const tinyAction = async function (where, type, args) {
+  // Try
+  try {
+    // Production
+    if (!isDebug) {
+      // Date Now
+      const now = moment();
+
+      // Update Counter
+      let count = tinyCache[where].count[type];
+      tinyCache[where].count[type]++;
+
+      // New Date
+      if (
+        (lastUpdate.moment && lastUpdate.moment.date() !== now.date()) ||
+        tinyCache[where].count[type] > cacheLimit
+      ) {
+        await tinyCache[where].db.remove();
+        for (const item in tinyCache[where].count) {
+          tinyCache[where].count[item] = 0;
+        }
+      }
+
+      // Update Time
+      lastUpdate.moment = now;
+      lastUpdate.number = lastUpdate.moment.valueOf();
+
+      // Check Args
+      const insertArgs = [];
+      for (const item in args) {
+        // Is Error
+        if (args[item] instanceof Error) {
+          try {
+            args[item] = JSON.parse(JSON.stringify(args[item]));
+          } catch (err) {
+            console.error(err);
+          }
+        }
+
+        // Object Type
+        const type = objType(args[item]);
+
+        // Insert Args
+        if (type === 'string' || type === 'number' || type === 'object' || type === 'array')
+          insertArgs.push(args[item]);
+      }
+
+      // Add Log
+      if (insertArgs.length > 0) {
+        await tinyCache[where].db.child(type).child(count).set({
+          time: lastUpdate.number,
+          args: insertArgs,
+        });
+      }
+
+      // Nope
+      else {
+        tinyCache[where].count[type]--;
+        if (tinyCache[where].count[type] < 0) tinyCache[where].count[type] = 0;
+      }
+    }
+  } catch (err) {
+    // Error
+    console.error(`ERROR IN ${where} (${type})!`);
+    console.error(err);
+  }
+};
+
+// Is Debug
+let isDebug = false;
+
+/**
+ * Updates the last update time with the provided value, if it's newer than the current one.
+ *
+ * @param {number} value - The timestamp of the update to check against the last update.
+ * @returns {void}
+ */
+const checkLastTime = function (value) {
+  // Update
+  if (!lastUpdate.number || value > lastUpdate.number) {
+    lastUpdate.moment = moment(value);
+    lastUpdate.number = lastUpdate.moment.valueOf();
+  }
+};
+
+/**
+ * Generates a logger object with methods for different types of logging (log, error, info, warn).
+ * Each log type is stored in the database with a timestamp and arguments.
+ *
+ * @param {string} where - The location or context where the log is coming from.
+ * @returns {Object} The logger object with methods for logging (log, error, info, warn).
+ */
+const loggerGenerator = function (where) {
+  // Done
+  return {
+    // Log
+    log: async function () {
+      console.log.apply(console, arguments);
+      tinyAction(where, 'log', arguments);
+    },
+
+    // Error
+    error: async function () {
+      console.error.apply(console, arguments);
+      tinyAction(where, 'error', arguments);
+    },
+
+    // Info
+    info: async function () {
+      console.info.apply(console, arguments);
+      tinyAction(where, 'info', arguments);
+    },
+
+    // Warning
+    warn: async function () {
+      console.warn.apply(console, arguments);
+      tinyAction(where, 'warn', arguments);
+    },
+  };
+};
+
+/**
+ * Database logger module that manages logging actions and stores logs in a database.
+ * It provides functionality to start the logger with a new database instance,
+ * retrieve the logger instance, change the cache limit, and set debug mode.
+ *
+ * @module databaseLogger
+ */
+const databaseLogger = {
+  /**
+   * Starts the logger with a new database instance and initializes cache values.
+   *
+   * @param {Object} newDB - The new database instance to use for storing logs.
+   * @param {string} where - The context or location where the logger will be used.
+   * @returns {Promise<Object>} The logger instance with methods for logging.
+   */
+  start: async function (newDB, where) {
+    // Prepare
+    tinyCache[where] = { db: newDB, count: { log: 0, error: 0, info: 0, warn: 0 } };
+    let loggerCache = null;
+    if (!isDebug) {
+      loggerCache = await getDBData(tinyCache[where].db);
+      if (loggerCache) {
+        try {
+          if (loggerCache.log) {
+            tinyCache[where].count.log = loggerCache.log.length;
+            for (const item in loggerCache.log) {
+              if (typeof loggerCache.log[item].time === 'number') {
+                checkLastTime(loggerCache.log[item].time);
+              }
+            }
+          }
+          if (loggerCache.error) {
+            tinyCache[where].count.error = loggerCache.error.length;
+            for (const item in loggerCache.error) {
+              if (typeof loggerCache.error[item].time === 'number') {
+                checkLastTime(loggerCache.error[item].time);
+              }
+            }
+          }
+          if (loggerCache.info) {
+            tinyCache[where].count.info = loggerCache.info.length;
+            for (const item in loggerCache.info) {
+              if (typeof loggerCache.info[item].time === 'number') {
+                checkLastTime(loggerCache.info[item].time);
+              }
+            }
+          }
+          if (loggerCache.warn) {
+            tinyCache[where].count.warn = loggerCache.warn.length;
+            for (const item in loggerCache.warn) {
+              if (typeof loggerCache.warn[item].time === 'number') {
+                checkLastTime(loggerCache.warn[item].time);
+              }
+            }
+          }
+        } catch (err) {
+          console.error(err);
+          isDebug = true;
+        }
+      }
+    }
+
+    // Complete
+    return loggerGenerator(where);
+  },
+
+  /**
+   * Retrieves the logger instance for a given context.
+   *
+   * @param {string} where - The context or location where the logger will be used.
+   * @returns {Object} The logger instance with methods for logging.
+   */
+  get: function (where) {
+    return loggerGenerator(where);
+  },
+
+  /**
+   * Changes the cache limit for the logger.
+   *
+   * @param {number} value - The new cache limit to set.
+   * @returns {void}
+   */
+  changeCacheLimit: function (value) {
+    if (typeof value === 'number') cacheLimit = value;
+  },
+
+  /**
+   * Enables or disables debug mode.
+   *
+   * @param {boolean} value - `true` to enable debug mode, `false` to disable it.
+   * @returns {void}
+   */
+  setDebugMode: function (value) {
+    isDebug = value;
+  },
+};
+
+module.exports = databaseLogger;

package/dist/legacy/firebase/databaseLogger.d.mts

@@ -0,0 +1,7 @@
+export default databaseLogger;
+declare namespace databaseLogger {
+    function start(newDB: Object, where: string): Promise<Object>;
+    function get(where: string): Object;
+    function changeCacheLimit(value: number): void;
+    function setDebugMode(value: boolean): void;
+}