@trap_stevo/filetide 0.0.0

package/dist/cjs/FileMessager.js

@@ -0,0 +1,82 @@
+"use strict";
+
+const IoTide = require("@trap_stevo/iotide");
+const {
+  FileMessagerConfigManager
+} = require("./HUDManagers/FileMessagerConfigManager");
+const {
+  FileUtilityManager
+} = require("./HUDManagers/FileUtilityManager");
+class FileMessager {
+  constructor(options = {}) {
+    const serverOptions = FileMessagerConfigManager.getServerOptions(options);
+    this.ioTide = new IoTide(serverOptions.port, serverOptions, true, this.onConnect.bind(this), this.onDisconnect.bind(this));
+    this.onlineClients = new Map();
+    return;
+  }
+  onConnect(socket) {
+    console.log(`Client connected: ${socket.id}`);
+    this.onlineClients.set(socket.id, socket);
+    socket.on("client-to-client-transfer", this.handleClientToClientTransfer.bind(this));
+    return;
+  }
+  onDisconnect(connectionRes, socket) {
+    console.log(`Client disconnected: ${socket.id}`);
+    this.onlineClients.delete(socket.id);
+    return;
+  }
+  start() {
+    this.ioTide.on("transfer-start", this.handleFileTransferStart.bind(this));
+    this.ioTide.on("transfer-progress", this.handleFileTransferProgress.bind(this));
+    this.ioTide.on("transfer-complete", this.handleFileTransferComplete.bind(this));
+    return;
+  }
+
+  /**
+   * Send file to a specific client
+   * @param {String} clientId - The ID of the client (socket ID)
+   * @param {Buffer} fileData - The file data to send
+   * @param {String} fileName - The name of the file
+   */
+  sendFileToClient(clientId, fileData, fileName, filePath = process.cwd()) {
+    const client = this.onlineClients.get(clientId);
+    if (!client) {
+      console.log(`Client with ID ${clientId} not found.`);
+      return;
+    }
+    client.emit("incoming-file", {
+      fileName,
+      fileData,
+      path: filePath
+    });
+    console.log(`File ${fileName} sent to client ${clientId}!`);
+    return;
+  }
+
+  /**
+   * Handle file transfer requests between clients
+   * @param {Object} transferData - The data containing the sender, recipient, and file details
+   */
+  handleClientToClientTransfer(transferData) {
+    const {
+      recipientId,
+      fileName,
+      fileData
+    } = transferData;
+    this.sendFileToClient(recipientId, fileData, fileName);
+    return;
+  }
+  handleFileTransferStart(fileData, emitToChannel) {
+    console.log(`Starting file transfer: ${fileData.fileName}`);
+    return;
+  }
+  handleFileTransferProgress(data, emitToChannel) {
+    console.log(`Progress: ${data.progress}`);
+    return;
+  }
+  handleFileTransferComplete(data) {
+    console.log(`File transfer completed: ${data.fileName}`);
+    return;
+  }
+}
+module.exports = FileMessager;

package/dist/cjs/FileMessagerClient.js

@@ -0,0 +1,71 @@
+"use strict";
+
+const {
+  HUDIoTide
+} = require("@trap_stevo/iotide-client");
+const {
+  FileMessagerConfigManager
+} = require("./HUDManagers/FileMessagerConfigManager");
+const {
+  FileUtilityManager
+} = require("./HUDManagers/FileUtilityManager");
+class FileMessagerClient {
+  constructor(options = {}) {
+    this.clientOptions = FileMessagerConfigManager.getClientOptions(options);
+    this.clientTide = new HUDIoTide();
+    this.clients = new Map();
+  }
+  createClientInstance(clientID, clientOptions) {
+    this.clientTide.createIO(clientID, clientOptions.url, {
+      transports: ["websocket"]
+    });
+    console.log(`[FileMessagerClient] ~ Created client with ID ${clientID} and socket ${clientID}`);
+    return clientID;
+  }
+  joinRoom(userID, roomName) {
+    const socketName = this.createClientInstance(userID, {
+      url: this.clientOptions.url
+    });
+    this.clientTide.joinChannel(socketName, roomName, userID, () => {
+      console.log(`Client ${userID} joined room ${roomName} successfully.`);
+      this.clients.set(userID, {
+        roomName
+      });
+    });
+  }
+  sendFile(recipientId, fileName, fileData, path = process.cwd()) {
+    this.clientTide.emitEvent("client-to-client-transfer", {
+      recipientId,
+      fileName,
+      fileData,
+      path
+    });
+    console.log(`File ${fileName} sent to client ${recipientId}.`);
+  }
+  onFileChunkReceived(userID) {
+    this.clientTide.onEvent(userID, "transfer-progress", data => {
+      console.log(`Receiving file chunk for user ${userID}: `, data.fileChunk);
+      console.log("Progress: ", data.progress);
+      FileUtilityManager.saveChunk(userID, data.fileChunk, data.path, data.name);
+    });
+  }
+  onFileTransferComplete(userID) {
+    this.clientTide.onEvent(userID, "transfer-complete", data => {
+      console.log(`File transfer completed for user ${userID}.`);
+      FileUtilityManager.assembleFile(userID);
+    });
+  }
+  handleIncomingFile(userID) {
+    this.clientTide.onEvent(userID, "incoming-file", data => {
+      console.log(`Received file for user ${userID}: ${data.fileName}.`);
+      FileUtilityManager.saveFile(data.fileName, data.fileData, data.path, data.name);
+    });
+  }
+  handleMultipleClientsTransfer() {
+    this.clients.forEach((userID, roomData) => {
+      this.onFileChunkReceived(userID);
+      this.onFileTransferComplete(userID);
+    });
+  }
+}
+module.exports = FileMessagerClient;

package/dist/cjs/FileTide.js

@@ -0,0 +1,151 @@
+"use strict";
+
+function _classPrivateMethodInitSpec(e, a) { _checkPrivateRedeclaration(e, a), a.add(e); }
+function _checkPrivateRedeclaration(e, t) { if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object"); }
+function _assertClassBrand(e, t, n) { if ("function" == typeof e ? e === t : e.has(t)) return arguments.length < 3 ? t : n; throw new TypeError("Private element is not present on this object"); }
+const FileMessagerClient = require("./FileMessagerClient");
+const FileMessager = require("./FileMessager");
+const path = require("path");
+const fs = require("fs");
+var _FileTide_brand = /*#__PURE__*/new WeakSet();
+class FileTide {
+  constructor(config = {}) {
+    /**
+     * Set up file transfer event listeners natively.
+     * Automatically checks and creates directories as needed.
+     */
+    _classPrivateMethodInitSpec(this, _FileTide_brand);
+    this.config = config;
+    this.fileNet = null;
+    this.clients = new Map();
+    return;
+  }
+
+  /**
+   * Initialize and start the server.
+   * @param {Object} serverOptions - Configuration for server (e.g., port, useCors, useHTTPS)
+   * @param {Function} onLaunch - Callback for when a file tide instance launches
+   */
+  launchFileTide(serverOptions = {}, onLaunch) {
+    this.fileNet = new FileMessager(serverOptions);
+    this.fileNet.start();
+    console.log("[FileTide] ~ FileNet launched successfully!");
+    if (onLaunch) {
+      onLaunch(this.fileNet);
+    }
+  }
+
+  /**
+   * Initialize and start a new client for each user.
+   * @param {Object} clientOptions - Configuration for client (e.g., serverUrl)
+   * @param {String} roomName - The name of the room to join
+   * @param {String} userID - The ID of the client user
+   * @param {Function} onLaunch - Callback for when a file messager launches
+   */
+  launchMessager(clientOptions = {}, roomName, userID, onLaunch, onIncomingFile) {
+    if (this.clients.has(userID)) {
+      console.log(`[FileTide] ~ Client for user ${userID} already exists.`);
+      return;
+    }
+    const newClient = new FileMessagerClient(clientOptions);
+    newClient.joinRoom(userID, roomName);
+    newClient.handleMultipleClientsTransfer();
+    this.clients.set(userID, newClient);
+    console.log(`[FileTide] ~ Messager launched successfully for user ${userID}!`);
+    _assertClassBrand(_FileTide_brand, this, _setupFileEventListeners).call(this, userID, newClient, onIncomingFile);
+    if (onLaunch) {
+      onLaunch(newClient);
+    }
+    return;
+  }
+  /**
+   * Send a file directly to a device without it needing to create a client.
+   * @param {String} userID - The ID of the client device to send the file to
+   * @param {Buffer} fileData - The file data to send
+   * @param {String} fileName - The name of the file
+   */
+  sendFileToDevice(userID, fileData, filePath, fileName) {
+    if (this.fileNet.onlineClients.has(userID)) {
+      console.log(`[FileTide] ~ Sending file to user ${userID}...`);
+      this.fileNet.sendFileToClient(userID, fileData, filePath, fileName);
+      console.log(`[FileTide] ~ File sent to user ${userID}!`);
+      return;
+    }
+    console.log(`[FileTide] ~ No active client found for user ${userID}.`);
+    return;
+  }
+
+  /**
+   * Check if running in server mode.
+   * @returns {Boolean} - True if running as a server
+   */
+  fileTideOperational() {
+    return this.fileNet !== null;
+  }
+
+  /**
+   * Check if running in client mode.
+   * @returns {Boolean} - True if any client is active
+   */
+  messagerOperational() {
+    return this.clients.size > 0;
+  }
+
+  /**
+   * Stop the server if it"s running.
+   */
+  stopFileTide() {
+    if (this.fileNet) {
+      console.log("Stopping FileTide...");
+      this.fileNet = null;
+      console.log("Stopped FileTide.");
+    }
+    return;
+  }
+
+  /**
+   * Stop a specific client.
+   * @param {String} userID - The ID of the client user to stop
+   */
+  stopMessager(userID) {
+    if (this.clients.has(userID)) {
+      console.log(`Stopping messager for user ${userID}...`);
+      this.clients.delete(userID);
+      console.log(`Stopped messager for user ${userID}.`);
+      return;
+    }
+    console.log(`No active messager found for user ${userID}.`);
+    return;
+  }
+
+  /**
+   * Stop all active clients.
+   */
+  stopAllMessagers() {
+    console.log("Stopping all messagers...");
+    this.clients.clear();
+    console.log("All messagers stopped.");
+    return;
+  }
+}
+function _setupFileEventListeners(userID, client, onIncomingFile) {
+  client.clientTide.onEvent(userID, "incoming-file", data => {
+    console.log(`[Client] Received file: ${data.fileName}`);
+    const saveDir = data.path;
+    if (!fs.existsSync(saveDir)) {
+      fs.mkdirSync(saveDir, {
+        recursive: true
+      });
+      console.log(`[Client] Created directory: ${saveDir}`);
+    }
+    const savePath = path.join(saveDir, data.fileName);
+    fs.writeFileSync(savePath, Buffer.from(data.fileData));
+    console.log(`[Client] File saved at: ${savePath}`);
+    if (onIncomingFile) {
+      onIncomingFile(data);
+    }
+  });
+  return;
+}
+;
+module.exports = FileTide;

package/dist/cjs/HUDManagers/FileMessagerConfigManager.js

@@ -0,0 +1,34 @@
+"use strict";
+
+class FileMessagerConfigManager {
+  static getServerOptions({
+    port = 9269,
+    useCors = true,
+    useHTTPS = false,
+    corsOrigin = "*",
+    ...rest
+  } = {}) {
+    return {
+      port,
+      useCors,
+      useHTTPS,
+      socketOptions: {
+        cors: {
+          origin: corsOrigin,
+          methods: ["GET", "POST"]
+        }
+      },
+      ...rest
+    };
+  }
+  static getClientOptions({
+    serverUrl = 'http://localhost:3000'
+  } = {}) {
+    return {
+      url: serverUrl
+    };
+  }
+}
+module.exports = {
+  FileMessagerConfigManager
+};

package/dist/cjs/HUDManagers/FileUtilityManager.js

@@ -0,0 +1,48 @@
+"use strict";
+
+const path = require('path');
+const fs = require('fs');
+const filesPath = path.join(__dirname, '../files');
+class FileUtilityManager {
+  /**
+   * Save a chunk of a file for a specific user to the specified path with a custom file name.
+   * @param {String} userID - The ID of the user for whom the file is being saved.
+   * @param {Buffer} chunk - The file chunk to save.
+   * @param {String} savePath - The directory where the file should be saved.
+   * @param {String} fileName - The name of the file being saved.
+   */
+  static saveChunk(userID, chunk, savePath, fileName = "${Date.now()}_temp_file") {
+    const filePath = path.join(savePath || filesPath, fileName || `${userID}_${Date.now()}`);
+    fs.appendFileSync(filePath, chunk);
+    console.log(`Saved chunk for user ${userID} to ${filePath}.`);
+  }
+
+  /**
+   * Assemble the final file from chunks for a specific user with a custom file name.
+   * @param {String} userID - The ID of the user whose file is being assembled.
+   * @param {String} savePath - The directory where the file should be saved.
+   * @param {String} fileName - The name of the final file to assemble.
+   */
+  static assembleFile(userID, savePath, fileName = `${Date.now()}_final_file`) {
+    const tempFilePath = path.join(savePath || filesPath, `${userID}_${Date.now()}`);
+    const finalFilePath = path.join(savePath || filesPath, fileName || `${userID}_${Date.now()}`);
+    fs.renameSync(tempFilePath, finalFilePath);
+    console.log(`Assembled file for user ${userID} at ${finalFilePath}.`);
+  }
+
+  /**
+   * Save a complete file directly to a specified path with a custom file name.
+   * @param {String} fileName - The name of the file to save.
+   * @param {Buffer} fileData - The complete file data to save.
+   * @param {String} savePath - The directory where the file should be saved.
+   */
+  static saveFile(fileName = "${Date.now()}_temp_file", fileData, savePath) {
+    const filePath = path.join(savePath || filesPath, fileName || `${userID}_${Date.now()}`);
+    fs.writeFileSync(filePath, fileData);
+    console.log(`Saved file ${fileName} to ${filePath}.`);
+  }
+}
+module.exports = {
+  FileUtilityManager,
+  filesPath
+};

package/dist/cjs/HUDManagers/LomlLoggingSystem.js

@@ -0,0 +1,379 @@
+"use strict";
+
+const {
+  HUDIoTide
+} = require("@trap_stevo/iotide-client");
+const IoTide = require("@trap_stevo/iotide");
+const Loml = require("@trap_stevo/loml");
+class LomlLoggingSystem {
+  constructor(config = {}, ...args) {
+    this.lomlLogging = null;
+    this.clientInstance = config.clientInstance || false;
+    this.serverInstance = config.serverInstance || false;
+    this.setupIoTideInstance(config.lomlLoggingSystemOptions, ...args);
+    if (this.clientInstance) {
+      this.lomlLoggerClient = new HUDIoTide();
+      this.initializeClient(config.clientOptions);
+    }
+    if (this.serverInstance) {
+      this.lomlLogging.on("external-log", data => {
+        this.processExternalLog(data);
+      });
+    }
+  }
+  setupIoTideInstance(lomlLoggingSystemOptions, ...args) {
+    if (this.serverInstance) {
+      this.lomlLogging = new IoTide(lomlLoggingSystemOptions.port || 3069, lomlLoggingSystemOptions.options || {}, ...args);
+      this.lomlLogging.server.listen(lomlLoggingSystemOptions.port || 3069, "0.0.0.0", () => {
+        console.log(`LomlLoggingSystem ~ ${lomlLoggingSystemOptions.port || 3069}`);
+      });
+    }
+  }
+  initializeClient(clientOptions) {
+    const {
+      socketName,
+      url,
+      options,
+      onConnect
+    } = clientOptions;
+    this.lomlLoggerClient.createIO(socketName, url, options);
+    this.lomlLoggerClient.onEvent(socketName, "connect", () => {
+      console.log("Connected to the LomlLoggingSystem!");
+      if (onConnect) {
+        onConnect(this.lomlLoggerClient);
+      }
+    });
+  }
+  processExternalLog(data) {
+    const {
+      roomName,
+      tideID,
+      text,
+      styles,
+      colors,
+      direction,
+      href,
+      tag,
+      type,
+      protocol
+    } = data;
+    const loml = new Loml();
+    let formattedMessage;
+    switch (type) {
+      case "text":
+        formattedMessage = loml.text(text, styles).build();
+        break;
+      case "bold":
+        formattedMessage = loml.bold(text, styles).build();
+        break;
+      case "italic":
+        formattedMessage = loml.italic(text, styles).build();
+        break;
+      case "link":
+        formattedMessage = loml.link(text, href, styles).build();
+        break;
+      case "color":
+        formattedMessage = loml.color(text, styles.color, styles).build();
+        break;
+      case "gradientText":
+        formattedMessage = loml.gradientText(text, colors, direction, styles).build();
+        break;
+      case "customElement":
+        formattedMessage = loml.element(tag, text, styles).build();
+        break;
+      default:
+        formattedMessage = loml.text(text, styles).build();
+    }
+    if (protocol && protocol === "system") {
+      this.lomlLogging.emitTide("log", {
+        message: formattedMessage
+      });
+      return formattedMessage;
+    }
+    if (roomName) {
+      this.lomlLogging.emitToChannel(tideID, roomName, "log", {
+        message: formattedMessage
+      });
+      return formattedMessage;
+    }
+    this.lomlLogging.emit("log", {
+      message: formattedMessage
+    });
+    return formattedMessage;
+  }
+  logToAll(text, styles = {}) {
+    const loml = new Loml();
+    const formattedMessage = loml.text(text, styles).build();
+    this.lomlLogging.emit("log", {
+      message: formattedMessage
+    });
+    return formattedMessage;
+  }
+  logToRoom(tideID, roomName, text, styles = {}) {
+    const loml = new Loml();
+    const formattedMessage = loml.text(text, styles).build();
+    this.lomlLogging.emitToChannel(tideID, roomName, "log", {
+      message: formattedMessage
+    });
+    return formattedMessage;
+  }
+  logBoldToAll(text, styles = {}) {
+    const loml = new Loml();
+    const formattedMessage = loml.bold(text, styles).build();
+    this.lomlLogging.emit("log", {
+      message: formattedMessage
+    });
+    return formattedMessage;
+  }
+  logBoldToRoom(tideID, roomName, text, styles = {}) {
+    const loml = new Loml();
+    const formattedMessage = loml.bold(text, styles).build();
+    this.lomlLogging.emitToChannel(tideID, roomName, "log", {
+      message: formattedMessage
+    });
+    return formattedMessage;
+  }
+  logItalicToAll(text, styles = {}) {
+    const loml = new Loml();
+    const formattedMessage = loml.italic(text, styles).build();
+    this.lomlLogging.emit("log", {
+      message: formattedMessage
+    });
+    return formattedMessage;
+  }
+  logItalicToRoom(tideID, roomName, text, styles = {}) {
+    const loml = new Loml();
+    const formattedMessage = loml.italic(text, styles).build();
+    this.lomlLogging.emitToChannel(tideID, roomName, "log", {
+      message: formattedMessage
+    });
+    return formattedMessage;
+  }
+  logLinkToAll(text, href, styles = {}) {
+    const loml = new Loml();
+    const formattedMessage = loml.link(text, href, styles).build();
+    this.lomlLogging.emit("log", {
+      message: formattedMessage
+    });
+    return formattedMessage;
+  }
+  logLinkToRoom(tideID, roomName, text, href, styles = {}) {
+    const loml = new Loml();
+    const formattedMessage = loml.link(text, href, styles).build();
+    this.lomlLogging.emitToChannel(tideID, roomName, "log", {
+      message: formattedMessage
+    });
+    return formattedMessage;
+  }
+  logColorToAll(text, color, styles = {}) {
+    const loml = new Loml();
+    const formattedMessage = loml.color(text, color, styles).build();
+    this.lomlLogging.emit("log", {
+      message: formattedMessage
+    });
+    return formattedMessage;
+  }
+  logColorToRoom(tideID, roomName, text, color, styles = {}) {
+    const loml = new Loml();
+    const formattedMessage = loml.color(text, color, styles).build();
+    this.lomlLogging.emitToChannel(tideID, roomName, "log", {
+      message: formattedMessage
+    });
+    return formattedMessage;
+  }
+  logGradientTextToRoom(tideID, roomName, text, colors, direction = "to right", styles = {}) {
+    const loml = new Loml();
+    const formattedMessage = loml.gradientText(text, colors, direction, styles).build();
+    this.lomlLogging.emitToChannel(tideID, roomName, "log", {
+      message: formattedMessage
+    });
+    return formattedMessage;
+  }
+  logGradientTextToAll(text, colors, direction = "to right", styles = {}) {
+    const loml = new Loml();
+    const formattedMessage = loml.gradientText(text, colors, direction, styles).build();
+    this.lomlLogging.emit("log", {
+      message: formattedMessage
+    });
+    return formattedMessage;
+  }
+  logCustomElementToAll(tag, text, styles = {}) {
+    const loml = new Loml();
+    const formattedMessage = loml.element(tag, text, styles).build();
+    this.lomlLogging.emit("log", {
+      message: formattedMessage
+    });
+    return formattedMessage;
+  }
+  logCustomElementToRoom(tideID, roomName, tag, text, styles = {}) {
+    const loml = new Loml();
+    const formattedMessage = loml.element(tag, text, styles).build();
+    this.lomlLogging.emitToChannel(tideID, roomName, "log", {
+      message: formattedMessage
+    });
+    return formattedMessage;
+  }
+  logLineBreakToAll() {
+    const loml = new Loml();
+    const formattedMessage = loml.br().build();
+    this.lomlLogging.emit("log", {
+      message: formattedMessage
+    });
+    return formattedMessage;
+  }
+  logLineBreakToRoom(tideID, roomName) {
+    const loml = new Loml();
+    const formattedMessage = loml.br().build();
+    this.lomlLogging.emitToChannel(tideID, roomName, "log", {
+      message: formattedMessage
+    });
+    return formattedMessage;
+  }
+  logStyledMessageToAll(messageParts) {
+    const loml = new Loml();
+    messageParts.forEach(part => {
+      if (typeof loml[part.method] === "function") {
+        loml[part.method](...part.args);
+      }
+    });
+    const formattedMessage = loml.build();
+    this.lomlLogging.emit("log", {
+      message: formattedMessage
+    });
+    return formattedMessage;
+  }
+  logStyledMessageToRoom(tideID, roomName, messageParts) {
+    const loml = new Loml();
+    messageParts.forEach(part => {
+      if (typeof loml[part.method] === "function") {
+        loml[part.method](...part.args);
+      }
+    });
+    const formattedMessage = loml.build();
+    this.lomlLogging.emitToChannel(tideID, roomName, "log", {
+      message: formattedMessage
+    });
+    return formattedMessage;
+  }
+  logTextToSystem(text, styles = {}) {
+    const loml = new Loml();
+    const formattedMessage = loml.text(text, styles).build();
+    this.lomlLogging.emitTide("log", {
+      message: formattedMessage
+    });
+    return formattedMessage;
+  }
+  logBoldToSystem(text, styles = {}) {
+    const loml = new Loml();
+    const formattedMessage = loml.bold(text, styles).build();
+    this.lomlLogging.emitTide("log", {
+      message: formattedMessage
+    });
+    return formattedMessage;
+  }
+  logItalicToSystem(text, styles = {}) {
+    const loml = new Loml();
+    const formattedMessage = loml.italic(text, styles).build();
+    this.lomlLogging.emitTide("log", {
+      message: formattedMessage
+    });
+    return formattedMessage;
+  }
+  logLinkToSystem(text, href, styles = {}) {
+    const loml = new Loml();
+    const formattedMessage = loml.link(text, href, styles).build();
+    this.lomlLogging.emitTide("log", {
+      message: formattedMessage
+    });
+    return formattedMessage;
+  }
+  logColorToSystem(text, color, styles = {}) {
+    const loml = new Loml();
+    const formattedMessage = loml.color(text, color, styles).build();
+    this.lomlLogging.emitTide("log", {
+      message: formattedMessage
+    });
+    return formattedMessage;
+  }
+  logGradientTextToSystem(text, colors, direction = "to right", styles = {}) {
+    const loml = new Loml();
+    const formattedMessage = loml.gradientText(text, colors, direction, styles).build();
+    this.lomlLogging.emitTide("log", {
+      message: formattedMessage
+    });
+    return formattedMessage;
+  }
+  logCustomElementToSystem(tag, text, styles = {}) {
+    const loml = new Loml();
+    const formattedMessage = loml.element(tag, text, styles).build();
+    this.lomlLogging.emitTide("log", {
+      message: formattedMessage
+    });
+    return formattedMessage;
+  }
+  logLineBreakToSystem() {
+    const loml = new Loml();
+    const formattedMessage = loml.br().build();
+    this.lomlLogging.emitTide("log", {
+      message: formattedMessage
+    });
+    return formattedMessage;
+  }
+  logStyledMessageToSystem(messageParts) {
+    const loml = new Loml();
+    messageParts.forEach(part => {
+      if (typeof loml[part.method] === "function") {
+        loml[part.method](...part.args);
+      }
+    });
+    const formattedMessage = loml.build();
+    this.lomlLogging.emitTide("log", {
+      message: formattedMessage
+    });
+    return formattedMessage;
+  }
+  static log(options = {}) {
+    const {
+      text = "Sample text",
+      type = "text",
+      direction = "to right",
+      colors = [],
+      styles = {},
+      href = "",
+      tag = "span",
+      logToConsole = true
+    } = options;
+    const loml = new Loml();
+    let formattedMessage;
+    switch (type) {
+      case "text":
+        formattedMessage = loml.text(text, styles).build();
+        break;
+      case "bold":
+        formattedMessage = loml.bold(text, styles).build();
+        break;
+      case "italic":
+        formattedMessage = loml.italic(text, styles).build();
+        break;
+      case "link":
+        formattedMessage = loml.link(text, href, styles).build();
+        break;
+      case "color":
+        formattedMessage = loml.color(text, styles.color, styles).build();
+        break;
+      case "gradientText":
+        formattedMessage = loml.gradientText(text, colors, direction, styles).build();
+        break;
+      case "customElement":
+        formattedMessage = loml.element(tag, text, styles).build();
+        break;
+      default:
+        formattedMessage = loml.text(text, styles).build();
+    }
+    if (logToConsole) {
+      console.log(`${type.charAt(0).toUpperCase() + type.slice(1)} Log:`, formattedMessage);
+    }
+    return formattedMessage;
+  }
+}
+module.exports = LomlLoggingSystem;

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@trap_stevo/filetide",
+  "version": "0.0.0",
+  "description": "Revolutionizing real-time file transfer with seamless, instant communication across any device. Deliver files instantly, regardless of platform, and experience unparalleled speed and control in managing transfers. Elevate your file-sharing capabilities with a tool designed for precision, efficiency, and effortless connectivity.",
+  "main": "dist/cjs/FileTide.js",
+  "scripts": {
+    "build": "babel src -d dist/cjs --env-name cjs",
+    "start": "node dist/cjs/FileTide.js"
+  },
+  "keywords": [
+    "real-time",
+    "nodejs",
+    "ota",
+    "over-the-air",
+    "file communication",
+    "file transfer",
+    "device-to-device",
+    "cross-platform",
+    "instant messaging",
+    "file sharing",
+    "peer-to-peer",
+    "P2P",
+    "network transfer",
+    "data transfer",
+    "seamless connectivity"
+  ],
+  "author": "Steven Compton",
+  "license": "ISC",
+  "dependencies": {
+    "@trap_stevo/iotide": "^0.0.36",
+    "@trap_stevo/iotide-client": "^0.0.14"
+  },
+  "devDependencies": {
+    "@babel/cli": "^7.24.8",
+    "@babel/core": "^7.25.2",
+    "@babel/plugin-proposal-class-properties": "^7.18.6",
+    "@babel/plugin-transform-runtime": "^7.24.7",
+    "@babel/preset-env": "^7.25.3"
+  }
+}