@trap_stevo/filetide 0.0.13 → 0.0.15

package/dist/cjs/FileMessager.js

@@ -5,13 +5,19 @@ const {
   FileMessagerConfigManager
 } = require("./HUDManagers/FileMessagerConfigManager");
 const {
-  FileUtilityManager
-} = require("./HUDManagers/FileUtilityManager");
+  FileNetClientManager
+} = require("./HUDManagers/FileNetClientManager");
+const {
+  FileTransferManager
+} = require("./HUDManagers/FileTransferManager");
 class FileMessager {
-  constructor(options = {}) {
+  constructor(options = {}, transportOptions = {
+    parallelChunks: 3,
+    maxRetries: 3
+  }) {
     const serverOptions = FileMessagerConfigManager.getServerOptions(options);
+    this.transporter = new FileTransferManager(transportOptions);
     this.fileNet = new IoTide(serverOptions.port, serverOptions, true, this.onConnect.bind(this), this.onDisconnect.bind(this));
-    this.messagerClients = new Map();
     this.onlineClients = new Map();
     return;
   }
@@ -37,96 +43,100 @@ class FileMessager {
   }
 
   /**
-   * Send file to a specific client
+   * Send file chunk to a specific client
    * @param {String} senderID - The ID of the sender (tide ID)
    * @param {String} clientId - The ID of the client (socket ID)
-   * @param {Buffer} fileData - The file data to send
+   * @param {Buffer} fileChunk - The file chunk to send
    * @param {String} fileName - The name of the file
+   * @param {Number} chunkIndex - The index of the current chunk
    */
-  sendFileToClient(senderID, clientId, fileData, fileName, filePath = process.cwd()) {
-    if (!this.messagerClients.has(clientId)) {
-      console.log(`Client ~ ${clientId} not authorized.`);
-      return;
-    }
-    const senderConnectionID = this.messagerClients.get(senderID);
-    const connectionID = this.messagerClients.get(clientId);
-    const senderClient = this.onlineClients.get(connectionID);
-    const client = this.onlineClients.get(connectionID);
+  sendFileChunkToClient(senderID, clientId, fileChunk, fileName, chunkIndex, totalChunks, filePath = process.cwd()) {
+    const client = this.onlineClients.get(clientId);
     if (!client) {
       console.log(`Client ~ ${clientId} not found.`);
       return;
     }
-    client.emit("incoming-file", {
+    if (chunkIndex === 0) {
+      client.emit("incoming-file", {
+        fileName,
+        totalChunks,
+        chunkIndex,
+        path: filePath
+      });
+    }
+    client.emit("transfer-progress", {
       fileName,
-      fileData,
+      fileChunk,
+      chunkIndex,
       path: filePath
     });
-    console.log(`[FileTide ~ File Messager] ~ File ${fileName} sent to client ~ ${clientId}!`);
+    console.log(`[FileTide ~ File Messager] ~ Sent chunk ${chunkIndex} of ${fileName} to client ~ ${clientId}!`);
+    const senderClient = this.onlineClients.get(senderID);
     if (senderClient) {
       senderClient.emit("transfer-status", {
-        status: `[FileTide ~ File Messager] ~ File ${fileName} sent to client ~ ${clientId}!`,
+        status: `Chunk ${chunkIndex} of ${fileName} sent to client ${clientId}!`,
         recipientID: clientId,
         success: true
       });
     }
-    return;
   }
-
-  /**
-   * Handle file transfer requests between clients
-   * @param {Object} transferData - The data containing the sender, recipient, and file details
-   */
   handleClientToClientTransfer(transferData) {
     const {
       senderID,
       recipientId,
       fileName,
-      fileData,
-      filePath
+      fileChunk,
+      filePath,
+      chunkIndex,
+      totalChunks
     } = transferData;
-    this.sendFileToClient(senderID, recipientId, fileData, fileName, filePath);
-    return;
+    console.log(`Transferring file ~ ${fileName} | chunk ${chunkIndex + 1} of ${totalChunks} to client (${recipientId})`);
+    this.sendFileChunkToClient(FileNetClientManager.getOnlineClient(senderID).id, FileNetClientManager.getOnlineClient(recipientId).id, fileChunk, fileName, chunkIndex, totalChunks, filePath);
+    if (chunkIndex + 1 === totalChunks) {
+      this.fileNet.emit("transfer-complete", {
+        senderID,
+        recipientId,
+        fileName,
+        filePath
+      });
+      console.log(`[FileTide ~ File Messager] ~ File transfer completed: ${fileName} from ${senderID} to ${recipientId}`);
+    }
+  }
+  handleFileTransferStart(fileData, emitToChannel) {
+    console.log(`Starting file transfer: ${fileData.fileName}`);
+  }
+  handleFileTransferProgress(data, emitToChannel) {
+    console.log(`Progress: ${data.progress}`);
+  }
+  handleFileTransferComplete(data) {
+    console.log(`File transfer completed: ${data.fileName}`);
   }
   handleClientsOnline(clientID) {
-    if (!this.messagerClients.has(clientID)) {
+    if (!FileNetClientManager.getOnlineClient(clientID)) {
       console.log(`Client ~ ${clientID} not authorized.`);
       return;
     }
-    const connectionID = this.messagerClients.get(clientID);
+    const connectionID = FileNetClientManager.getOnlineClient(clientID);
     const client = this.onlineClients.get(connectionID);
     if (!client) {
       console.log(`Client ~ ${clientID} not found.`);
       return;
     }
-    client.emit("current-clients-online", {
-      currentClients: this.messagerClients
+    this.fileNet.emitToTide(client.tideID, "current-clients-online", {
+      currentClients: FileNetClientManager.getOnlineClients()
     });
     return;
   }
-  handleClientOnline(clientID, connectionID) {
+  handleClientOnline(clientID, tideID, pClientID, connectionID) {
     if (!this.onlineClients.has(connectionID)) {
       return;
     }
-    this.messagerClients.set(clientID, connectionID);
+    FileNetClientManager.addOnlineClient(clientID, pClientID, tideID, connectionID);
+    this.fileNet.emitToTide(tideID, "current-online-clients", Object.fromEntries(FileNetClientManager.getOnlineClients()));
     return;
   }
   handleClientOffline(clientID) {
-    if (!this.messagerClients.has(clientID)) {
-      return;
-    }
-    this.messagerClients.delete(clientID);
-    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}`);
+    FileNetClientManager.clearOnlineClient(clientID);
     return;
   }
 }

package/dist/cjs/FileMessagerClient.js

@@ -6,12 +6,20 @@ const {
 const {
   FileMessagerConfigManager
 } = require("./HUDManagers/FileMessagerConfigManager");
+const {
+  FileTransferManager
+} = require("./HUDManagers/FileTransferManager");
 const {
   FileUtilityManager
 } = require("./HUDManagers/FileUtilityManager");
+const path = require("path");
 class FileMessagerClient {
-  constructor(options = {}) {
+  constructor(options = {}, transportOptions = {
+    parallelChunks: 3,
+    maxRetries: 3
+  }) {
     this.clientOptions = FileMessagerConfigManager.getClientOptions(options);
+    this.transporter = new FileTransferManager(transportOptions);
     this.clientTide = new HUDIoTide();
     this.clients = new Map();
   }
@@ -34,15 +42,71 @@ class FileMessagerClient {
       });
     });
   }
-  sendFile(clientID, recipientId, fileName, fileData, filePath = process.cwd()) {
-    this.clientTide.emitEvent(clientID, "client-to-client-transfer", {
-      senderID: clientID,
-      recipientId,
-      fileName,
-      fileData,
-      filePath
+
+  /**
+   * Sends all files in a directory in parallel using the sendFile method.
+   * @param {string} clientID - The ID of the client sending the files.
+   * @param {string} recipientId - The ID of the recipient.
+   * @param {Array} filesData - Array of file data objects from the directory.
+   * @param {string} baseDirectory - The base directory path that contains the files.
+   * @param {string} destinationPath - The path to which the files should be sent.
+   */
+  sendDirectoryFiles(clientID, recipientId, filesData, baseDirectory, destinationPath) {
+    const baseDirectoryName = path.basename(baseDirectory);
+    const adjustedDestinationPath = path.join(destinationPath, baseDirectoryName);
+    const sendFilePromises = filesData.map(fileInfo => {
+      const relativeFilePath = path.dirname(path.relative(baseDirectory, fileInfo.filePath));
+      const fileDestinationPath = path.join(adjustedDestinationPath, relativeFilePath);
+      return this.sendFile(clientID, recipientId, fileInfo.fileName, fileInfo.fileData, fileDestinationPath);
     });
-    return;
+    Promise.all(sendFilePromises).then(() => console.log("All files in directory transferred successfully!")).catch(error => console.error("Did not transfer files: ", error));
+  }
+  sendFile(clientID, recipientId, fileName, file, filePath = process.cwd()) {
+    console.log(fileName, ": ", file);
+    if (!file) {
+      return;
+    }
+    this.transporter.sendFile(file, {
+      onSendChunk: (transferId, chunkIndex, chunkData, totalChunks) => {
+        return new Promise((resolve, reject) => {
+          this.clientTide.emitEvent(clientID, "client-to-client-transfer", {
+            senderID: clientID,
+            recipientId,
+            fileName,
+            fileChunk: chunkData,
+            totalChunks,
+            chunkIndex,
+            filePath
+          });
+          console.log(`Chunk ${chunkIndex} sent successfully!`);
+          resolve();
+        });
+      },
+      onComplete: () => {
+        return new Promise((resolve, reject) => {
+          console.log({
+            senderID: clientID,
+            recipientId,
+            fileName,
+            filePath
+          });
+          this.clientTide.emitEvent(clientID, "transfer-complete", {
+            senderID: clientID,
+            recipientId,
+            fileName,
+            filePath
+          });
+          resolve();
+        });
+      },
+      onProgress: progress => {
+        console.log(`[FileTide ~ File Messager] ~ Progress: ${progress.toFixed(2)}%`);
+      },
+      fileDetails: {
+        name: fileName,
+        path: filePath
+      }
+    }).then(() => console.log('File transfer complete!')).catch(error => console.error('File transfer failed:', error));
   }
   onFileChunkReceived(userID) {
     this.clientTide.onEvent(userID, "transfer-progress", data => {

package/dist/cjs/FileTide.js

@@ -3,10 +3,18 @@
 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 chalk = require("chalk");
 const path = require("path");
 const fs = require("fs");
+const {
+  FileNetConfigManager
+} = require("./HUDManagers/FileNetConfigManager.js");
+const {
+  FileUtilityManager
+} = require("./HUDManagers/FileUtilityManager.js");
+const ConsoleTable = require("./HUDComponents/ConsoleTable.js");
+const FileMessagerClient = require("./FileMessagerClient");
+const FileMessager = require("./FileMessager");
 var _FileTide_brand = /*#__PURE__*/new WeakSet();
 class FileTide {
   constructor() {
@@ -57,6 +65,16 @@ class FileTide {
     }
     return;
   }
+  getDirectoryData(directoryPath) {
+    return FileUtilityManager.getDirectoryData(directoryPath);
+  }
+  getFileData(filePath) {
+    return FileUtilityManager.getFileData(filePath);
+  }
+  getPathData(inputPath) {
+    return FileUtilityManager.getPathData(inputPath);
+  }
+
   /**
    * Send a file directly to a device without it needing to create a client.
    * @param {String} senderID - The ID of the client device that sent the file
@@ -77,8 +95,54 @@ class FileTide {
         return;
       }
       console.log(`[FileTide] ~ Sending file to client ~ ${userID}...`);
-      this.fileNet.sendFileToClient(senderClient.tideID, currentClient.id, fileData, filePath, fileName);
-      console.log(`[FileTide] ~ File sent to client ~ ${userID}!`);
+      console.log({
+        recipientId: userID,
+        senderID,
+        fileName,
+        filePath,
+        fileData
+      });
+      this.fileNet.transporter.sendFile(fileData, {
+        onSendChunk: (transferId, chunkIndex, chunkData, totalChunks) => {
+          return new Promise((resolve, reject) => {
+            this.clientTide.emitEvent(senderID, "client-to-client-transfer", {
+              recipientId: userID,
+              senderID,
+              fileName,
+              fileChunk: chunkData,
+              totalChunks,
+              chunkIndex,
+              filePath
+            }, ack => {
+              if (ack.success) {
+                console.log(`Chunk ${chunkIndex} sent successfully!`);
+                resolve();
+              } else {
+                console.error(`Did not send chunk ${chunkIndex}`);
+                reject(new Error('Chunk failed.'));
+              }
+            });
+          });
+        },
+        onComplete: transferId => {
+          return new Promise((resolve, reject) => {
+            this.clientTide.emitEvent(senderID, "transfer-complete", {
+              recipientId: userID,
+              senderID,
+              fileName,
+              filePath
+            });
+            resolve();
+          });
+        },
+        onProgress: progress => {
+          console.log(`[FileTide ~ File Messager] ~ Progress: ${progress.toFixed(2)}%`);
+        },
+        fileDetails: {
+          name: fileName,
+          path: filePath
+        }
+      }).then(() => console.log("File transfer complete!")).catch(error => console.error("File transfer incomplete: ", error));
       return;
     }
     console.log(`[FileTide] ~ No active client ~ ${userID} found.`);
@@ -139,22 +203,90 @@ class FileTide {
   }
 }
 function _setupFileEventListeners(userID, client, onIncomingFile) {
+  const cliTable = new ConsoleTable({
+    padding: 2,
+    headerAlign: "center",
+    cellAlign: "left",
+    borderStyle: "bold",
+    columnOrder: ["clientID", "id", "tideID"],
+    columnNames: {
+      clientID: "Client Name",
+      id: "Identifier",
+      tideID: "Tide Identifier"
+    },
+    title: "✨ Online ✨",
+    tableNumber: 1,
+    gradient: {
+      title: ["#00FFFF", "#1E90FF"],
+      header: ["#FFD700", "#FF8C00"],
+      border: ["#2e2f30", "#788e9e"],
+      cell: ["#00BFFF", "#1E90FF"]
+    },
+    cellColor: (content, column) => {
+      if (column === "clientID") {
+        return chalk.blue(content);
+      }
+      return content;
+    }
+  });
+  let activeTransfers = new Map();
+  client.clientTide.onEvent(userID, "current-online-clients", data => {
+    const currentClients = {};
+    Object.keys(data).forEach(key => {
+      if (key !== userID) {
+        currentClients[key] = data[key];
+      }
+    });
+    if (Object.keys(currentClients).length <= 0) {
+      return;
+    }
+    cliTable.setTitle(`✨ Online >${Object.keys(currentClients).length}< ✨`, 1);
+    cliTable.setData(currentClients);
+    console.log(`\n[FileTide ~ FileNet]\n\n`, cliTable.render(), "\n");
+  });
   client.clientTide.onEvent(userID, "incoming-file", data => {
-    console.log(`[${userID}] Received file: ${data.fileName}`);
+    console.log(`[${userID}] Preparing to receive file : ${data.fileName}`);
+    activeTransfers.set(data.fileName, {
+      receivedChunks: [],
+      totalChunks: data.totalChunks,
+      fileInfo: data
+    });
     const saveDir = data.path;
     if (!fs.existsSync(saveDir)) {
       fs.mkdirSync(saveDir, {
         recursive: true
       });
-      console.log(`[${userID}] Created directory: ${saveDir}`);
+      console.log(`[${userID}] Created directory : ${saveDir}`);
+    }
+  });
+  client.clientTide.onEvent(userID, "transfer-progress", data => {
+    if (!data || data.fileChunk === undefined || data.fileChunk === null) {
+      return;
+    }
+    const transferState = activeTransfers.get(data.fileName);
+    if (!transferState) {
+      return;
     }
-    const savePath = path.join(saveDir, data.fileName);
-    fs.writeFileSync(savePath, Buffer.from(data.fileData));
-    console.log(`[${userID}] File saved at: ${savePath}`);
+    console.log(`[${userID}] Receiving chunk ${data.chunkIndex + 1}/${transferState.totalChunks} for file : ${data.fileName}`);
+    transferState.receivedChunks[data.chunkIndex] = Buffer.from(data.fileChunk);
+    const progress = (data.chunkIndex + 1) / transferState.totalChunks * 100;
+    console.log(`[${userID}] Progress : ${progress.toFixed(2)}%`);
     if (onIncomingFile) {
       onIncomingFile(data);
     }
   });
+  client.clientTide.onEvent(userID, "transfer-complete", data => {
+    console.log(`[${userID}] File transfer complete : ${data.fileName}`);
+    const transferState = activeTransfers.get(data.fileName);
+    if (!transferState) {
+      return;
+    }
+    const savePath = path.join(data.filePath, data.fileName);
+    const fullFile = Buffer.concat(transferState.receivedChunks);
+    fs.writeFileSync(savePath, fullFile);
+    console.log(`[${userID}] File saved at : ${savePath}`);
+    activeTransfers.delete(data.fileName);
+  });
   return;
 }
 ;

package/dist/cjs/HUDComponents/ConsoleTable.js

@@ -0,0 +1,349 @@
+"use strict";
+
+const chalk = require("chalk");
+class ConsoleTable {
+  constructor(options = {}) {
+    this.options = {
+      padding: 1,
+      headerAlign: "center",
+      cellAlign: "left",
+      borderStyle: "solid",
+      headerColor: null,
+      borderColor: null,
+      cellColor: (content, columnName, rowData) => content,
+      columnOrder: null,
+      columnNames: {},
+      title: "",
+      tableNumber: null,
+      gradient: {
+        title: null,
+        header: null,
+        border: null,
+        cell: null
+      },
+      ...options
+    };
+    this.borderChars = this.getBorderChars(this.options.borderStyle);
+  }
+  getBorderChars(style) {
+    const styles = {
+      solid: {
+        topLeft: "┌",
+        topRight: "┐",
+        bottomLeft: "└",
+        bottomRight: "┘",
+        horizontal: "─",
+        vertical: "│",
+        topJoin: "┬",
+        bottomJoin: "┴",
+        leftJoin: "├",
+        rightJoin: "┤",
+        center: "┼"
+      },
+      double: {
+        topLeft: "╔",
+        topRight: "╗",
+        bottomLeft: "╚",
+        bottomRight: "╝",
+        horizontal: "═",
+        vertical: "║",
+        topJoin: "╦",
+        bottomJoin: "╩",
+        leftJoin: "╠",
+        rightJoin: "╣",
+        center: "╬"
+      },
+      round: {
+        topLeft: "╭",
+        topRight: "╮",
+        bottomLeft: "╰",
+        bottomRight: "╯",
+        horizontal: "─",
+        vertical: "│",
+        topJoin: "┬",
+        bottomJoin: "┴",
+        leftJoin: "├",
+        rightJoin: "┤",
+        center: "┼"
+      },
+      bold: {
+        topLeft: "┏",
+        topRight: "┓",
+        bottomLeft: "┗",
+        bottomRight: "┛",
+        horizontal: "━",
+        vertical: "┃",
+        topJoin: "┳",
+        bottomJoin: "┻",
+        leftJoin: "┣",
+        rightJoin: "┫",
+        center: "╋"
+      }
+    };
+    return styles[style] || styles["solid"];
+  }
+  setData(data) {
+    if (Array.isArray(data)) {
+      this.data = data;
+    } else if (typeof data === "object") {
+      this.data = Object.values(data);
+    } else {
+      throw new Error("Array or an object only.");
+    }
+    this.extractColumns();
+    this.calculateColumnWidths();
+  }
+  extractColumns() {
+    if (this.options.columnOrder && Array.isArray(this.options.columnOrder)) {
+      this.columns = this.options.columnOrder;
+    } else {
+      const columnsSet = new Set();
+      this.data.forEach(item => {
+        Object.keys(item).forEach(key => columnsSet.add(key));
+      });
+      this.columns = Array.from(columnsSet);
+    }
+  }
+  calculateColumnWidths() {
+    const {
+      padding
+    } = this.options;
+    this.columnWidths = {};
+    this.totalWidth = 0;
+    this.columns.forEach(column => {
+      const headerName = this.options.columnNames[column] || column;
+      let maxWidth = String(headerName).length;
+      this.data.forEach(item => {
+        const cellContent = item[column] !== undefined ? String(item[column]) : "";
+        maxWidth = Math.max(maxWidth, cellContent.length);
+      });
+      const columnWidth = maxWidth + padding * 2;
+      this.columnWidths[column] = columnWidth;
+      this.totalWidth += columnWidth;
+    });
+    this.totalWidth += this.columns.length + 1;
+  }
+  alignText(text, width, align) {
+    const {
+      padding
+    } = this.options;
+    const textLength = text.length;
+    let totalPadding = width - textLength;
+    let leftPadding = " ".repeat(padding);
+    let rightPadding = " ".repeat(padding);
+    if (totalPadding < padding * 2) {
+      leftPadding = "";
+      rightPadding = "";
+    } else {
+      totalPadding -= padding * 2;
+      if (align === "left") {
+        rightPadding += " ".repeat(totalPadding);
+      } else if (align === "right") {
+        leftPadding += " ".repeat(totalPadding);
+      } else {
+        const half = Math.floor(totalPadding / 2);
+        leftPadding += " ".repeat(half);
+        rightPadding += " ".repeat(totalPadding - half);
+      }
+    }
+    return leftPadding + text + rightPadding;
+  }
+  generateGradientText(text, startColor, endColor) {
+    const length = text.length;
+    const startRGB = this.hexToRgb(startColor);
+    const endRGB = this.hexToRgb(endColor);
+    let gradientText = "";
+    for (let i = 0; i < length; i++) {
+      const ratio = i / (length - 1 || 1);
+      const color = {
+        r: Math.round(startRGB.r + ratio * (endRGB.r - startRGB.r)),
+        g: Math.round(startRGB.g + ratio * (endRGB.g - startRGB.g)),
+        b: Math.round(startRGB.b + ratio * (endRGB.b - startRGB.b))
+      };
+      gradientText += chalk.rgb(color.r, color.g, color.b)(text[i]);
+    }
+    return gradientText;
+  }
+  hexToRgb(hex) {
+    const result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
+    return result ? {
+      r: parseInt(result[1], 16),
+      g: parseInt(result[2], 16),
+      b: parseInt(result[3], 16)
+    } : null;
+  }
+  generateBorder(type) {
+    const {
+      columns,
+      columnWidths
+    } = this;
+    let {
+      horizontal,
+      vertical,
+      topLeft,
+      topRight,
+      bottomLeft,
+      bottomRight,
+      topJoin,
+      bottomJoin,
+      leftJoin,
+      rightJoin,
+      center
+    } = this.borderChars;
+    const {
+      borderColor
+    } = this.options;
+    const borderGradient = this.options.gradient.border;
+    if (borderGradient && borderGradient.length === 2) {
+      const chars = [topLeft, topRight, bottomLeft, bottomRight, horizontal, vertical, topJoin, bottomJoin, leftJoin, rightJoin, center];
+      const coloredChars = {};
+      chars.forEach((char, index) => {
+        coloredChars[char] = this.generateGradientText(char, borderGradient[0], borderGradient[1]);
+      });
+      bottomRight = coloredChars[bottomRight];
+      bottomLeft = coloredChars[bottomLeft];
+      topRight = coloredChars[topRight];
+      topLeft = coloredChars[topLeft];
+      horizontal = coloredChars[horizontal];
+      vertical = coloredChars[vertical];
+      bottomJoin = coloredChars[bottomJoin];
+      rightJoin = coloredChars[rightJoin];
+      leftJoin = coloredChars[leftJoin];
+      topJoin = coloredChars[topJoin];
+      center = coloredChars[center];
+    } else if (borderColor) {
+      bottomRight = borderColor(bottomRight);
+      bottomLeft = borderColor(bottomLeft);
+      topRight = borderColor(topRight);
+      topLeft = borderColor(topLeft);
+      horizontal = borderColor(horizontal);
+      vertical = borderColor(vertical);
+      bottomJoin = borderColor(bottomJoin);
+      rightJoin = borderColor(rightJoin);
+      leftJoin = borderColor(leftJoin);
+      topJoin = borderColor(topJoin);
+      center = borderColor(center);
+    }
+    let border = "";
+    columns.forEach((column, index) => {
+      const first = index === 0;
+      const last = index === columns.length - 1;
+      const width = columnWidths[column];
+      const line = horizontal.repeat(width);
+      if (type === "top") {
+        border += first ? topLeft : topJoin;
+      } else if (type === "bottom") {
+        border += first ? bottomLeft : bottomJoin;
+      } else {
+        border += first ? leftJoin : center;
+      }
+      border += line;
+      if (last) {
+        if (type === "top") {
+          border += topRight;
+        } else if (type === "bottom") {
+          border += bottomRight;
+        } else {
+          border += rightJoin;
+        }
+      }
+    });
+    return border;
+  }
+  generateRow(rowData, headerRow = false) {
+    const {
+      columns,
+      columnWidths
+    } = this;
+    let {
+      vertical
+    } = this.borderChars;
+    const {
+      headerAlign,
+      cellAlign,
+      headerColor,
+      cellColor
+    } = this.options;
+    const align = headerRow ? headerAlign : cellAlign;
+    const headerGradient = this.options.gradient.header;
+    const cellGradient = this.options.gradient.cell;
+    const borderGradient = this.options.gradient.border;
+    if (borderGradient && borderGradient.length === 2) {
+      vertical = this.generateGradientText(vertical, borderGradient[0], borderGradient[1]);
+    } else if (this.options.borderColor) {
+      vertical = this.options.borderColor(vertical);
+    }
+    let row = "";
+    columns.forEach((column, index) => {
+      const content = rowData[column] !== undefined ? String(rowData[column]) : "";
+      const width = columnWidths[column];
+      const alignedText = this.alignText(content, width, align);
+      let cellContent = alignedText;
+      const first = index === 0;
+      if (headerRow) {
+        if (headerGradient && headerGradient.length === 2) {
+          cellContent = this.generateGradientText(cellContent, headerGradient[0], headerGradient[1]);
+        } else if (headerColor) {
+          cellContent = headerColor(cellContent);
+        }
+      } else {
+        if (cellGradient && cellGradient.length === 2) {
+          cellContent = this.generateGradientText(cellContent, cellGradient[0], cellGradient[1]);
+        } else if (cellColor) {
+          cellContent = cellColor(cellContent, column, rowData);
+        }
+      }
+      if (first) {
+        row += vertical;
+      }
+      row += cellContent + vertical;
+    });
+    return row;
+  }
+  setTitle(title, tableNumber = null) {
+    this.options.title = title;
+    if (tableNumber !== null) {
+      this.options.tableNumber = tableNumber;
+    }
+  }
+  renderTitle() {
+    let titleText = this.options.title;
+    if (this.options.tableNumber !== null) {
+      titleText = titleText;
+    }
+    const totalWidth = this.totalWidth - 2;
+    const titleLength = titleText.length;
+    let leftPadding = Math.floor((totalWidth - titleLength) / 2);
+    if (leftPadding < 0) leftPadding = 0;
+    let titleLine = " ".repeat(leftPadding) + titleText;
+    const titleGradient = this.options.gradient.title;
+    if (titleGradient && titleGradient.length === 2) {
+      titleLine = this.generateGradientText(titleLine.trim(), titleGradient[0], titleGradient[1]);
+    }
+    return titleLine;
+  }
+  render() {
+    const {
+      data
+    } = this;
+    if (!data || data.length === 0) return "";
+    const lines = [];
+    if (this.options.title) {
+      const title = this.renderTitle();
+      lines.push(title);
+    }
+    lines.push(this.generateBorder("top"));
+    const headerData = {};
+    this.columns.forEach(column => {
+      headerData[column] = this.options.columnNames[column] || column;
+    });
+    lines.push(this.generateRow(headerData, true));
+    lines.push(this.generateBorder("middle"));
+    data.forEach(rowData => {
+      lines.push(this.generateRow(rowData));
+    });
+    lines.push(this.generateBorder("bottom"));
+    return lines.join("\n");
+  }
+}
+module.exports = ConsoleTable;

package/dist/cjs/HUDManagers/FileNetClientManager.js

@@ -0,0 +1,33 @@
+"use strict";
+
+const currentOnlineClients = new Map();
+class FileNetClientManager {
+  static addOnlineClient(clientID, pClientID, tideID, id) {
+    if (currentOnlineClients.get(pClientID)) {
+      currentOnlineClients.delete(pClientID);
+    }
+    currentOnlineClients.set(clientID, {
+      pClientID: pClientID || "",
+      clientID,
+      tideID,
+      id
+    });
+    return currentOnlineClients;
+  }
+  static clearOnlineClient(clientID) {
+    if (!currentOnlineClients.get(clientID)) {
+      return currentOnlineClients;
+    }
+    currentOnlineClients.delete(clientID);
+    return currentOnlineClients;
+  }
+  static getOnlineClient(clientID) {
+    return currentOnlineClients.get(clientID);
+  }
+  static getOnlineClients() {
+    return currentOnlineClients;
+  }
+}
+module.exports = {
+  FileNetClientManager
+};

package/dist/cjs/HUDManagers/FileNetConfigManager.js

@@ -0,0 +1,32 @@
+"use strict";
+
+const currentOnlineClients = new Map();
+class FileNetConfigManager {
+  static addOnlineClient(clientID, pClientID, tideID) {
+    if (currentOnlineClients.get(pClientID)) {
+      currentOnlineClients.delete(pClientID);
+    }
+    currentOnlineClients.set(clientID, {
+      pClientID: pClientID || "",
+      clientID,
+      tideID
+    });
+    return currentOnlineClients;
+  }
+  static clearOnlineClient(clientID, tideID) {
+    if (!currentOnlineClients.get(clientID)) {
+      return currentOnlineClients;
+    }
+    currentOnlineClients.delete(clientID);
+    return currentOnlineClients;
+  }
+  static getOnlineClient(clientID) {
+    if (!currentOnlineClients.get(clientID)) {
+      return null;
+    }
+    return currentOnlineClients.get(clientID);
+  }
+}
+module.exports = {
+  FileNetConfigManager
+};

package/dist/cjs/HUDManagers/FileTransferManager.js

@@ -0,0 +1,104 @@
+"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 fs = require("fs");
+var _FileTransferManager_brand = /*#__PURE__*/new WeakSet();
+class FileTransferManager {
+  constructor({
+    chunkSize = 512 * 1024,
+    parallelChunks = 5,
+    maxRetries = 3
+  } = {}) {
+    _classPrivateMethodInitSpec(this, _FileTransferManager_brand);
+    this.parallelChunks = parallelChunks;
+    this.activeTransfers = new Map();
+    this.maxRetries = maxRetries;
+    this.chunkSize = chunkSize;
+  }
+  sendFile(file, {
+    fileDetails,
+    onSendChunk,
+    onComplete,
+    onProgress,
+    onStart
+  }) {
+    const transferId = _assertClassBrand(_FileTransferManager_brand, this, _generateTransferId).call(this, fileDetails);
+    return _assertClassBrand(_FileTransferManager_brand, this, _startTransfer).call(this, file, transferId, fileDetails, onSendChunk, onComplete, onProgress, onStart);
+  }
+}
+function _startTransfer(file, transferId, fileDetails, onSendChunk, onComplete, onProgress, onStart) {
+  const totalChunks = Math.ceil(file.length / this.chunkSize);
+  this.activeTransfers.set(transferId, {
+    totalChunks,
+    completedChunks: 0,
+    activeChunks: 0,
+    failedChunks: new Map(),
+    currentChunk: 0
+  });
+  const updateProgress = () => {
+    const transferState = this.activeTransfers.get(transferId);
+    if (onProgress) {
+      onProgress(transferState.completedChunks / transferState.totalChunks * 100);
+    }
+  };
+  return new Promise((resolve, reject) => {
+    const sendChunk = chunkIndex => {
+      const transferState = this.activeTransfers.get(transferId);
+      if (chunkIndex >= transferState.totalChunks) return;
+      const start = chunkIndex * this.chunkSize;
+      const end = Math.min(start + this.chunkSize, file.length);
+      const chunk = file.slice(start, end);
+      if (!fs.existsSync(fileDetails.path)) {
+        fs.mkdirSync(fileDetails.path, {
+          recursive: true
+        });
+        console.log(`[FileTide ~ Transporter] Created directory: ${fileDetails.path}`);
+      }
+      if (onStart && chunkIndex === 0) {
+        onStart({
+          name: fileDetails.name,
+          path: fileDetails.path,
+          totalChunks: transferState.totalChunks
+        });
+      }
+      transferState.activeChunks++;
+      onSendChunk(transferId, chunkIndex, chunk, transferState.totalChunks).then(() => {
+        transferState.completedChunks++;
+        transferState.activeChunks--;
+        updateProgress();
+        if (transferState.activeChunks < this.parallelChunks && transferState.currentChunk < transferState.totalChunks) {
+          sendChunk(transferState.currentChunk++);
+        }
+        if (transferState.completedChunks === transferState.totalChunks) {
+          onComplete(transferId).then(() => {
+            this.activeTransfers.delete(transferId);
+            resolve();
+          }).catch(reject);
+        }
+      }).catch(error => {
+        console.error(`Did not send chunk ${chunkIndex}: ${error.message}`);
+        transferState.activeChunks--;
+        if (transferState.failedChunks.get(chunkIndex) >= this.maxRetries) {
+          this.activeTransfers.delete(transferId);
+          reject(new Error(`Did not send chunk ${chunkIndex} after ${this.maxRetries} retries.`));
+        } else {
+          const retryCount = (transferState.failedChunks.get(chunkIndex) || 0) + 1;
+          transferState.failedChunks.set(chunkIndex, retryCount);
+          sendChunk(chunkIndex);
+        }
+      });
+    };
+    const transferState = this.activeTransfers.get(transferId);
+    for (let i = 0; i < Math.min(this.parallelChunks, transferState.totalChunks); i++) {
+      sendChunk(transferState.currentChunk++);
+    }
+  });
+}
+function _generateTransferId(file) {
+  return `${file.name}-${Date.now()}`;
+}
+module.exports = {
+  FileTransferManager
+};

package/dist/cjs/HUDManagers/FileUtilityManager.js

@@ -4,6 +4,115 @@ const path = require('path');
 const fs = require('fs');
 const filesPath = path.join(__dirname, '../files');
 class FileUtilityManager {
+  /**
+   * Recursively calculates the total size of files in a directory.
+   * @param {string} dirPath - The directory path.
+   * @returns {number} - The total size in bytes of the directory's contents.
+   */
+  calculateDirectorySize(dirPath) {
+    let totalSize = 0;
+    const files = fs.readdirSync(dirPath);
+    files.forEach(file => {
+      const filePath = path.join(dirPath, file);
+      const stats = fs.statSync(filePath);
+      if (stats.isDirectory()) {
+        totalSize += this.calculateDirectorySize(filePath);
+      } else {
+        totalSize += stats.size;
+      }
+    });
+    return totalSize;
+  }
+
+  /**
+   * Normalizes the input path to handle both single and double slashes.
+   * @param {string} inputPath - The path to normalize.
+   * @returns {string} - A normalized path with proper slashes.
+   */
+  static normalizePath(inputPath) {
+    return path.normalize(inputPath);
+  }
+
+  /**
+   * Gets all files' data from a given directory.
+   * @param {string} dirPath - The path to the directory.
+   * @returns {Array} - An array of objects containing file data, name, and path.
+   */
+  static getDirectoryData(inputDirPath) {
+    const dirPath = this.normalizePath(inputDirPath);
+    if (!fs.existsSync(dirPath)) {
+      console.log(`Directory at path ${dirPath} not found.`);
+      return [];
+    }
+    const filesData = [];
+    function readDirectory(currentPath) {
+      const fileList = fs.readdirSync(currentPath);
+      fileList.forEach(file => {
+        const filePath = path.join(currentPath, file);
+        const stats = fs.statSync(filePath);
+        if (stats.isFile()) {
+          const fileData = FileUtilityManager.getFileData(filePath);
+          if (fileData) {
+            filesData.push(fileData);
+          }
+        } else if (stats.isDirectory()) {
+          readDirectory(filePath);
+        }
+      });
+    }
+    readDirectory(dirPath);
+    return filesData;
+  }
+
+  /**
+   * Gets file data from a given file path.
+   * @param {string} inputFilePath - The full path to the file.
+   * @returns {Object|null} - An object containing file data, name, and path, or null if the file doesn't exist.
+   */
+  static getFileData(inputFilePath) {
+    const filePath = this.normalizePath(inputFilePath);
+    if (!fs.existsSync(filePath)) {
+      console.log(`File at path ${filePath} not found.`);
+      return null;
+    }
+    const fileData = fs.readFileSync(filePath, {
+      encoding: null
+    });
+    const fileName = path.basename(filePath);
+    return {
+      fileName,
+      fileData,
+      filePath
+    };
+  }
+
+  /**
+   * Gets data from a file or directory based on the provided path.
+   * @param {string} inputPath - The path to a file or directory.
+   * @returns {Object|Array|null} - File data if it's a file, an array of file data if it's a directory, or null if the path doesn't exist.
+   */
+  static getPathData(inputPath) {
+    const currentInputPath = this.normalizePath(inputPath);
+    if (!fs.existsSync(currentInputPath)) {
+      console.log(`Path at ${currentInputPath} not found.`);
+      return null;
+    }
+    const stats = fs.statSync(currentInputPath);
+    if (stats.isFile()) {
+      return {
+        content: this.getFileData(currentInputPath),
+        type: "file"
+      };
+    } else if (stats.isDirectory()) {
+      return {
+        content: this.getDirectoryData(currentInputPath),
+        type: "directory"
+      };
+    }
+    console.log(`Path at ${currentInputPath} neither a file nor a directory.`);
+    return null;
+  }
+
   /**
    * 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.

package/package.json

@@ -1,10 +1,12 @@
 {
   "name": "@trap_stevo/filetide",
-  "version": "0.0.13",
+  "version": "0.0.15",
   "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-messager": "node demos/FileTideClientDemo.js",
+    "start-net": "node demos/FileTideNetDemo.js",
     "start": "node dist/cjs/FileTide.js"
   },
   "keywords": [
@@ -28,7 +30,8 @@
   "license": "ISC",
   "dependencies": {
     "@trap_stevo/iotide": "^0.0.36",
-    "@trap_stevo/iotide-client": "^0.0.14",
+    "@trap_stevo/iotide-client": "^0.0.15",
+    "chalk": "^4.1.2",
     "readline": "^1.3.0"
   },
   "devDependencies": {

package/test.txt

@@ -1 +0,0 @@
-oiyutryuihoj