@trap_stevo/filetide 0.0.25 → 0.0.27

package/dist/cjs/FileMessager.js

@@ -35,65 +35,104 @@ class FileMessager {
     this.fileNet.on("transfer-start", this.handleFileTransferStart.bind(this));
     this.fileNet.on("transfer-progress", this.handleFileTransferProgress.bind(this));
     this.fileNet.on("transfer-complete", this.handleFileTransferComplete.bind(this));
+    this.fileNet.on("request-transfer-from-client", this.handleRequestTransferFromClient.bind(this));
     this.fileNet.on("client-to-client-transfer", this.handleClientToClientTransfer.bind(this));
     this.fileNet.on("client-offline", this.handleClientOffline.bind(this));
     this.fileNet.on("clients-online", this.handleClientsOnline.bind(this));
     this.fileNet.on("client-online", this.handleClientOnline.bind(this));
     return;
   }
+  getClientFromID(clientID) {
+    const client = this.onlineClients.get(clientID);
+    if (!client) {
+      console.log(`Client ~ ${clientID} not found.`);
+      return;
+    }
+    return client;
+  }
+  requestFromClient(senderID, clientID, filePath = process.cwd(), destinationPath) {
+    const client = this.getClientFromID(clientID);
+    if (!client) {
+      return;
+    }
+    this.fileNet.emitToTide(client.tideID, "transfer-requested", {
+      senderID,
+      clientID,
+      path: filePath,
+      destinationPath
+    });
+  }
 
   /**
    * 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 {Object} senderData - Holds the ID (tide ID), and client name (userID) of the sender
+   * @param {Object} clientData - The ID (socket ID), and client name (userID) of the client
    * @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
    */
-  sendFileChunkToClient(senderID, clientId, fileChunk, fileName, chunkIndex, totalChunks, filePath = process.cwd()) {
-    const client = this.onlineClients.get(clientId);
+  sendFileChunkToClient(senderData, clientData, fileChunk, fileName, chunkIndex, totalChunks, filePath = process.cwd(), fileSize = 100) {
+    const senderClient = this.getClientFromID(senderData.id);
+    const client = this.getClientFromID(clientData.id);
     if (!client) {
-      console.log(`Client ~ ${clientId} not found.`);
       return;
     }
     if (chunkIndex === 0) {
       this.fileNet.emitToTide(client.tideID, "incoming-file", {
-        senderID,
+        senderID: senderData.userID,
+        clientID: clientData.userID,
         fileName,
         totalChunks,
         chunkIndex,
-        path: filePath
+        path: filePath,
+        fileSize
       });
     }
     this.fileNet.emitToTide(client.tideID, "transfer-progress", {
-      senderID,
+      senderID: senderData.id,
       fileName,
       fileChunk,
       chunkIndex,
-      path: filePath
+      path: filePath,
+      fileSize
     });
-    console.log(`[FileTide ~ File Messager] ~ Sent chunk ${chunkIndex} of ${fileName} to client ~ ${clientId}!`);
-    const senderClient = this.onlineClients.get(senderID);
+    console.log(`[FileTide ~ File Messager] ~ Sent chunk ${chunkIndex} of ${fileName} to client ~ ${clientData.userID}!`);
     if (senderClient) {
       this.fileNet.emitToTide(senderClient.tideID, "transfer-status", {
-        status: `Chunk ${chunkIndex} of ${fileName} sent to client ${clientId}!`,
-        recipientID: clientId,
+        status: `Chunk ${chunkIndex} of ${fileName} sent to client ${clientData.userID}!`,
+        recipientID: clientData.userID,
         success: true
       });
     }
   }
+  handleRequestTransferFromClient(transferData) {
+    const {
+      senderID,
+      recipientId,
+      filePath,
+      destinationPath
+    } = transferData;
+    this.requestFromClient(senderID, recipientId, filePath, destinationPath);
+  }
   handleClientToClientTransfer(transferData) {
     const {
       senderID,
       recipientId,
       fileName,
       fileChunk,
+      fileSize,
       filePath,
       chunkIndex,
       totalChunks
     } = transferData;
     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);
+    this.sendFileChunkToClient({
+      userID: senderID,
+      id: FileNetClientManager.getOnlineClient(senderID).id
+    }, {
+      userID: recipientId,
+      id: FileNetClientManager.getOnlineClient(recipientId).id
+    }, fileChunk, fileName, chunkIndex, totalChunks, filePath, fileSize);
     if (chunkIndex + 1 === totalChunks) {
       this.fileNet.emit("transfer-complete", {
         senderID,
@@ -104,8 +143,13 @@ class FileMessager {
       console.log(`[FileTide ~ File Messager] ~ File transfer completed: ${fileName} from ${senderID} to ${recipientId}`);
     }
   }
-  handleFileTransferStart(fileData, emitToChannel) {
-    console.log(`Starting file transfer: ${fileData.fileName}`);
+  handleFileTransferStart(data, emitToChannel) {
+    console.log(`Alerting client of incoming transfer from ${data.senderID}...`);
+    const client = this.getClientFromID(data.recipientID);
+    if (!client) {
+      return;
+    }
+    this.fileNet.emitToTide(client.tideID, "incoming-transfer", data);
   }
   handleFileTransferProgress(data, emitToChannel) {
     console.log(`Progress: ${data.progress}`);

package/dist/cjs/FileMessagerClient.js

@@ -3,6 +3,8 @@
 const {
   HUDIoTide
 } = require("@trap_stevo/iotide-client");
+const chalk = require("chalk");
+const path = require("path");
 const {
   FileMessagerConfigManager
 } = require("./HUDManagers/FileMessagerConfigManager");
@@ -12,7 +14,7 @@ const {
 const {
   FileUtilityManager
 } = require("./HUDManagers/FileUtilityManager");
-const path = require("path");
+const ConsoleProgressBarManager = require("./HUDComponents/ConsoleProgressBarManager");
 class FileMessagerClient {
   constructor(options = {}, transportOptions = {
     parallelChunks: 3,
@@ -20,6 +22,9 @@ class FileMessagerClient {
   }) {
     this.clientOptions = FileMessagerConfigManager.getClientOptions(options);
     this.transporter = new FileTransferManager(transportOptions);
+    this.progressBarManager = new ConsoleProgressBarManager([], {
+      completionMessageColor: chalk.blue.bold
+    });
     this.clientTide = new HUDIoTide();
     this.clients = new Map();
   }
@@ -54,19 +59,36 @@ class FileMessagerClient {
   sendDirectoryFiles(clientID, recipientId, filesData, baseDirectory, destinationPath) {
     const baseDirectoryName = path.basename(baseDirectory);
     const adjustedDestinationPath = FileUtilityManager.normalizePath(path.join(destinationPath, baseDirectoryName));
-    const sendFilePromises = filesData.map(fileInfo => {
+    const sendFilePromises = filesData.map((fileInfo, index) => {
       const relativeFilePath = path.dirname(path.relative(baseDirectory, fileInfo.filePath));
       const fileDestinationPath = FileUtilityManager.normalizePath(path.join(adjustedDestinationPath, relativeFilePath));
-      return this.sendFile(clientID, recipientId, fileInfo.fileName, fileInfo.fileData, fileDestinationPath);
+      return this.sendFile(clientID, recipientId, fileInfo.fileName, fileInfo.fileData, fileDestinationPath, fileInfo.size, adjustedDestinationPath, index);
     });
     Promise.all(sendFilePromises).then(() => console.log("\nAll files in directory transferred successfully!")).catch(error => console.error("Did not transfer files: ", error));
   }
-  sendFile(clientID, recipientId, fileName, file, filePath = process.cwd()) {
+  sendFile(clientID, recipientId, fileName, file, filePath = process.cwd(), fileSize, directoryPath = null, index = 0) {
     if (!file) {
       return;
     }
+    if (index === 0) {
+      this.progressBarManager.completionMessage = `Successfully sent to ${recipientId}!`;
+      this.progressBarManager.displayPage("Page Number:", "Press 'n' for next page, 'p' for previous page.", chalk.blue, chalk.magenta);
+      this.progressBarManager.listenForInput("Page Number:", "Press 'n' for next page, 'p' for previous page.", chalk.blue, chalk.magenta, chalk.yellow);
+      this.clientTide.emitEvent(clientID, "transfer-start", {
+        fileName,
+        senderID: clientID,
+        recipientID: recipientId,
+        path: directoryPath || filePath
+      });
+    }
     this.transporter.sendFile(file, {
       onSendChunk: (transferId, chunkIndex, chunkData, totalChunks) => {
+        if (chunkIndex === 0) {
+          this.progressBarManager.addTask({
+            name: fileName,
+            size: fileSize
+          });
+        }
         return new Promise((resolve, reject) => {
           this.clientTide.emitEvent(clientID, "client-to-client-transfer", {
             senderID: clientID,
@@ -75,7 +97,8 @@ class FileMessagerClient {
             fileChunk: chunkData,
             totalChunks,
             chunkIndex,
-            filePath
+            filePath,
+            fileSize
           });
           resolve();
         });
@@ -92,13 +115,18 @@ class FileMessagerClient {
         });
       },
       onProgress: progress => {
-        console.log(`\n[FileTide ~ File Messager] ~ ${progress.toFixed(2)}% |>>| ${fileName}`);
+        //console.log(`\n[FileTide ~ File Messager] ~ ${progress.toFixed(2)}% |>>| ${fileName}`);
+        this.progressBarManager.updateTaskProgress(fileName, 512 * 1024);
+      },
+      originDetails: {
+        recipientID: recipientId,
+        senderID: clientID
       },
       fileDetails: {
         name: fileName,
         path: filePath
       }
-    }).then(() => console.log(`[FileTide ~ File Messager] ~ File ~ ${fileName} transfer complete!`)).catch(error => console.error('File transfer failed:', error));
+    }).then(() => console.log(`[FileTide ~ File Messager] ~ File ~ ${fileName} transfer complete!`)).catch(error => console.error("Refused file transfer: ", error));
   }
   onFileChunkReceived(userID) {
     this.clientTide.onEvent(userID, "transfer-progress", data => {

package/dist/cjs/FileTide.js

@@ -12,6 +12,7 @@ const {
 const {
   FileUtilityManager
 } = require("./HUDManagers/FileUtilityManager.js");
+const ConsoleProgressBarManager = require("./HUDComponents/ConsoleProgressBarManager");
 const ConsoleTable = require("./HUDComponents/ConsoleTable.js");
 const FileMessagerClient = require("./FileMessagerClient");
 const FileMessager = require("./FileMessager");
@@ -23,6 +24,9 @@ class FileTide {
      * Automatically checks and creates directories as needed.
      */
     _classPrivateMethodInitSpec(this, _FileTide_brand);
+    this.progressBarManager = new ConsoleProgressBarManager([], {
+      completionMessageColor: chalk.blue.bold
+    });
     this.clients = new Map();
     return;
   }
@@ -74,6 +78,9 @@ class FileTide {
   getPathData(inputPath) {
     return FileUtilityManager.getPathData(inputPath);
   }
+  getTidePath(inputPath) {
+    return FileUtilityManager.getTidePath(inputPath);
+  }
 
   /**
    * Send a file directly to a device without it needing to create a client.
@@ -237,6 +244,12 @@ function _setupFileEventListeners(userID, client, onIncomingFile) {
     cliTable.setData(currentClients);
     console.log(`\n[FileTide ~ FileNet]\n\n`, cliTable.render(), "\n");
   });
+  client.clientTide.onEvent(userID, "incoming-transfer", data => {
+    console.log(`[${userID}] Preparing to receive transfer : ${FileUtilityManager.getTidePath(data.path)}`);
+    this.progressBarManager.completionMessage = `Successfully received transfer from ${recipientId}!`;
+    this.progressBarManager.displayPage("Page Number:", "Press 'n' for next page, 'p' for previous page.", chalk.blue, chalk.magenta);
+    this.progressBarManager.listenForInput("Page Number:", "Press 'n' for next page, 'p' for previous page.", chalk.blue, chalk.magenta, chalk.yellow);
+  });
   client.clientTide.onEvent(userID, "incoming-file", data => {
     console.log(`[${userID}] Preparing to receive file : ${data.fileName}`);
     activeTransfers.set(data.fileName, {
@@ -244,7 +257,11 @@ function _setupFileEventListeners(userID, client, onIncomingFile) {
       totalChunks: data.totalChunks,
       fileInfo: data
     });
-    const saveDir = FileUtilityManager.osPath(data.path);
+    const saveDir = FileUtilityManager.getTidePath(data.path);
+    this.progressBarManager.addTask({
+      name: data.fileName,
+      size: data.fileSize
+    });
     if (data.senderID && data.senderID !== userID && !fs.existsSync(saveDir)) {
       fs.mkdirSync(saveDir, {
         recursive: true
@@ -260,10 +277,15 @@ function _setupFileEventListeners(userID, client, onIncomingFile) {
     if (!transferState) {
       return;
     }
-    console.log(`[${userID}] Receiving chunk ${data.chunkIndex + 1}/${transferState.totalChunks} for file : ${data.fileName}`);
+
+    //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)}%`);
+
+    //console.log(`[${userID}] Progress : ${progress.toFixed(2)}%`);
+
+    this.progressBarManager.updateTaskProgress(data.fileName, 512 * 1024);
     if (onIncomingFile) {
       onIncomingFile(data);
     }
@@ -274,12 +296,15 @@ function _setupFileEventListeners(userID, client, onIncomingFile) {
     if (!transferState) {
       return;
     }
-    const savePath = FileUtilityManager.osPath(path.join(data.filePath, data.fileName));
+    const savePath = FileUtilityManager.getTidePath(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);
   });
+  client.clientTide.onEvent(userID, "transfer-request", data => {
+    console.log(`[${userID}] Transfer requested from: ${data.clientID}`);
+  });
   return;
 }
 ;

package/dist/cjs/HUDComponents/ConsoleProgressBarManager.js

@@ -0,0 +1,264 @@
+"use strict";
+
+const readline = require("readline");
+const chalk = require("chalk");
+class ConsoleProgressBarManager {
+  constructor(tasks = [], options = {}) {
+    this.visibleBars = process.stdout.rows - 3;
+    this.currentPage = 0;
+    this.barsPerPage = this.visibleBars;
+    this.maxCompletionFeedSize = 5;
+    this.completionTimeout = 5000;
+    this.completionFeed = [];
+    this.completedTasksCount = 0;
+    this.totalTasks = tasks.length;
+    this.taskBars = [];
+    this.options = options;
+    this.completionMessage = options.completionMessage || "Successfully processed all tasks!";
+    this.completionMessageColor = options.completionMessageColor || chalk.green;
+    this.allTasksCompleted = false;
+    this.taskBars = tasks.map((task, index) => this.createTaskBar(task, index));
+  }
+  convertSeconds(seconds) {
+    if (seconds === 0) return "0 s";
+    const units = [{
+      name: "y",
+      seconds: 60 * 60 * 24 * 365
+    }, {
+      name: "mo",
+      seconds: 60 * 60 * 24 * 30
+    }, {
+      name: "w",
+      seconds: 60 * 60 * 24 * 7
+    }, {
+      name: "d",
+      seconds: 60 * 60 * 24
+    }, {
+      name: "h",
+      seconds: 60 * 60
+    }, {
+      name: "m",
+      seconds: 60
+    }, {
+      name: "s",
+      seconds: 1
+    }];
+    let remainingSeconds = seconds;
+    let result = "";
+    for (const unit of units) {
+      const count = Math.floor(remainingSeconds / unit.seconds);
+      if (count > 0) {
+        result += `${count}${unit.name} `;
+        remainingSeconds %= unit.seconds;
+      }
+    }
+    return result.trim();
+  }
+  createTaskBar(task, index) {
+    const defaultOptions = {
+      barLength: 40,
+      filledChar: ">",
+      unfilledChar: " ",
+      barColor: chalk.hex("#00CED1").bold,
+      taskNameColor: chalk.hex("#007B7F").bold,
+      taskCompletedColor: chalk.hex("#2ED573").bold,
+      sizeTransferredColor: chalk.hex("#5ECAFF"),
+      totalSizeColor: chalk.hex("#00FFFF"),
+      taskETAColor: chalk.hex("#00BFFF"),
+      speedColor: chalk.hex("#90E0EF"),
+      percentageColor: chalk.hex("#1A936F").bold,
+      dynamicUnits: true
+    };
+    const settings = {
+      ...defaultOptions,
+      ...this.options
+    };
+    const newBar = {
+      taskName: task.name,
+      totalSize: task.size,
+      current: 0,
+      startTime: Date.now(),
+      taskIndex: index,
+      completed: false,
+      getFormattedSize: size => {
+        if (!settings.dynamicUnits) return `${size.toFixed(1)} B`;
+        const units = ["B", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"];
+        let unitIndex = 0;
+        while (size >= 1024 && unitIndex < units.length - 1) {
+          size /= 1024;
+          unitIndex++;
+        }
+        return `${size.toFixed(2)} ${units[unitIndex]}`;
+      },
+      getUnitData: size => {
+        if (!settings.dynamicUnits) return {
+          current: size.toFixed(1),
+          unit: "B"
+        };
+        const units = ["B", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"];
+        let unitIndex = 0;
+        while (size >= 1024 && unitIndex < units.length - 1) {
+          size /= 1024;
+          unitIndex++;
+        }
+        return {
+          current: size.toFixed(2),
+          unit: units[unitIndex]
+        };
+      },
+      redraw: () => {
+        readline.cursorTo(process.stdout, 0, newBar.taskIndex % this.barsPerPage);
+        process.stdout.clearLine();
+        if (newBar.completed) {
+          process.stdout.write(settings.taskCompletedColor(`${newBar.taskName}: Completed!`));
+          return;
+        }
+        const percentage = newBar.current / newBar.totalSize * 100;
+        const elapsedTime = (Date.now() - newBar.startTime) / 1000;
+        const speed = newBar.current / elapsedTime;
+        const speedData = newBar.getUnitData(speed);
+        const timeLeft = (newBar.totalSize - newBar.current) / (speed || 1);
+        newBar.progress = percentage;
+        newBar.timeLeft = timeLeft;
+        newBar.speed = speed;
+        const filledLength = Math.round(settings.barLength * (newBar.current / newBar.totalSize));
+        const bar = settings.barColor(settings.filledChar.repeat(filledLength)) + settings.unfilledChar.repeat(settings.barLength - filledLength);
+        process.stdout.write(`${settings.taskNameColor(newBar.taskName)} > ${settings.totalSizeColor(newBar.getFormattedSize(newBar.totalSize))} | ${settings.sizeTransferredColor(newBar.getFormattedSize(newBar.current))} ${settings.speedColor(`${speedData.current} ${speedData.unit}/s`)} | ${settings.taskETAColor(this.convertSeconds(timeLeft.toFixed(2)))} [${bar}] ${settings.percentageColor(percentage.toFixed(2) + "%")}`);
+      },
+      update: amount => {
+        newBar.current += amount;
+        if (newBar.current > newBar.totalSize) {
+          newBar.current = newBar.totalSize;
+        }
+        const startIndex = this.currentPage * this.barsPerPage;
+        const endIndex = startIndex + this.barsPerPage;
+        if (newBar.taskIndex >= startIndex && newBar.taskIndex < endIndex) {
+          newBar.redraw();
+        }
+      },
+      set: amount => {
+        newBar.current = amount;
+        if (newBar.current > newBar.totalSize) {
+          newBar.current = newBar.totalSize;
+        }
+        const startIndex = this.currentPage * this.barsPerPage;
+        const endIndex = startIndex + this.barsPerPage;
+        if (newBar.taskIndex >= startIndex && newBar.taskIndex < endIndex) {
+          newBar.redraw();
+        }
+      },
+      complete: () => {
+        newBar.completed = true;
+        this.completedTasksCount++;
+        if (this.completionFeed.length >= this.maxCompletionFeedSize) {
+          this.completionFeed.shift();
+        }
+        this.completionFeed.push(newBar.taskName);
+        newBar.redraw();
+        setTimeout(() => {
+          this.completionFeed = this.completionFeed.filter(task => task !== newBar.taskName);
+        }, this.completionTimeout);
+        if (this.completedTasksCount === this.totalTasks) {
+          this.allTasksCompleted = true;
+          this.exitInputListener();
+          this.displayPage();
+          this.displayCompletionMessage();
+        }
+      }
+    };
+    return newBar;
+  }
+  addTask(task) {
+    const index = this.taskBars.length;
+    const newTaskBar = this.createTaskBar(task, index);
+    this.taskBars.push(newTaskBar);
+    this.totalTasks++;
+  }
+  updateTaskProgress(taskName, amount) {
+    const taskBar = this.taskBars.find(bar => bar.taskName === taskName);
+    if (taskBar) {
+      taskBar.update(amount);
+      try {
+        if (taskBar.current >= taskBar.totalSize && taskBar.complete) {
+          taskBar.complete();
+        }
+      } catch (error) {}
+    } else {
+      console.log(chalk.red(`Task ${taskName} not found.`));
+    }
+  }
+  setTaskProgress(taskName, amount) {
+    const taskBar = this.taskBars.find(bar => bar.taskName === taskName);
+    if (taskBar) {
+      taskBar.set(amount);
+      if (taskBar.current >= taskBar.totalSize) {
+        taskBar.complete();
+      }
+    } else {
+      console.log(chalk.red(`Task ${taskName} not found.`));
+    }
+  }
+  clearPage() {
+    for (let i = 0; i < this.barsPerPage + 2; i++) {
+      readline.cursorTo(process.stdout, 0, i);
+      process.stdout.clearLine();
+    }
+  }
+  displayPage(customPagePrefix = "Page", bottomMessage, bottomMessageColor = chalk.gray) {
+    this.clearPage();
+    const startIndex = this.currentPage * this.barsPerPage;
+    const endIndex = startIndex + this.barsPerPage;
+    this.taskBars.slice(startIndex, endIndex).forEach(bar => {
+      bar.redraw();
+    });
+    if (!this.allTasksCompleted) {
+      this.redrawCompletionFeed(customPagePrefix, bottomMessage, bottomMessageColor);
+    }
+  }
+  redrawCompletionFeed(customPagePrefix = "Page", bottomMessage, pageFooterMessageColor = chalk.blue, bottomMessageColor = chalk.gray, recentlyCompletedColor = chalk.green) {
+    const bottomPosition = this.barsPerPage;
+    readline.cursorTo(process.stdout, 0, bottomPosition);
+    process.stdout.clearLine();
+    process.stdout.write(pageFooterMessageColor(`${customPagePrefix} ${this.currentPage + 1}/${Math.max(1, Math.ceil(this.taskBars.length / this.barsPerPage))} | Completed: ${this.completedTasksCount}/${this.totalTasks}`));
+    if (this.completionFeed.length > 0) {
+      process.stdout.write(recentlyCompletedColor(` | Recently completed: ${this.completionFeed.join(", ")}`));
+    }
+    readline.cursorTo(process.stdout, 0, bottomPosition + 1);
+    process.stdout.clearLine();
+    if (bottomMessage) {
+      process.stdout.write(bottomMessageColor(bottomMessage));
+    }
+  }
+  listenForInput(customPagePrefix = "Page", bottomMessage, bottomMessageColor = chalk.gray, recentlyCompletedColor = chalk.green) {
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.setEncoding("utf-8");
+    this.inputListener = key => {
+      if (key === "\u0003") {
+        process.exit();
+      } else if (this.allTasksCompleted) {
+        this.exitInputListener();
+      } else if (key === "n" && this.currentPage < Math.ceil(this.taskBars.length / this.barsPerPage) - 1) {
+        this.currentPage++;
+        this.displayPage(customPagePrefix, bottomMessage, bottomMessageColor, recentlyCompletedColor);
+      } else if (key === "p" && this.currentPage > 0) {
+        this.currentPage--;
+        this.displayPage(customPagePrefix, bottomMessage, bottomMessageColor, recentlyCompletedColor);
+      }
+    };
+    process.stdin.on("data", this.inputListener);
+  }
+  exitInputListener() {
+    process.stdin.removeListener("data", this.inputListener);
+    process.stdin.setRawMode(false);
+    process.stdin.resume();
+  }
+  displayCompletionMessage() {
+    const lastLine = Math.min(this.taskBars.length, this.barsPerPage);
+    readline.cursorTo(process.stdout, 0, lastLine);
+    process.stdout.clearLine();
+    console.log(this.completionMessageColor(this.completionMessage));
+  }
+}
+;
+module.exports = ConsoleProgressBarManager;

package/dist/cjs/HUDManagers/FileTransferManager.js

@@ -50,12 +50,6 @@ function _startTransfer(file, transferId, fileDetails, onSendChunk, onComplete,
       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,

package/dist/cjs/HUDManagers/FileUtilityManager.js

@@ -1,8 +1,9 @@
 "use strict";
 
-const path = require('path');
-const fs = require('fs');
-const filesPath = path.join(__dirname, '../files');
+const path = require("path");
+const fs = require("fs");
+const os = require("os");
+const filesPath = path.join(__dirname, "../files");
 class FileUtilityManager {
   /**
    * Recursively calculates the total size of files in a directory.
@@ -23,6 +24,45 @@ class FileUtilityManager {
     });
     return totalSize;
   }
+  static getTidePath(inputPath) {
+    const homeDir = os.homedir();
+    const platform = process.platform;
+    const folderMappings = {
+      ">Downloads": path.join(homeDir, "Downloads"),
+      ">Documents": path.join(homeDir, "Documents"),
+      ">Desktop": path.join(homeDir, "Desktop"),
+      ">AppData": platform === "win32" ? path.join(homeDir, "AppData", "Roaming") : path.join(homeDir, ".config"),
+      ">LocalAppData": platform === "win32" ? path.join(homeDir, "AppData", "Local") : "/var/local",
+      ">Music": path.join(homeDir, "Music"),
+      ">Pictures": path.join(homeDir, "Pictures"),
+      ">Videos": path.join(homeDir, "Videos"),
+      ">Public": platform === "win32" ? path.join("C:", "Users", "Public") : "/usr/share",
+      ">Templates": path.join(homeDir, "Templates"),
+      ">Temp": platform === "win32" ? path.join("C:", "Windows", "Temp") : "/tmp",
+      ">LogFiles": platform === "win32" ? path.join("C:", "Windows", "Logs") : "/var/log",
+      ">SystemRoot": platform === "win32" ? path.join("C:", "Windows") : "/",
+      ">Downloads": path.join(homeDir, "Downloads"),
+      ">Cache": platform === "win32" ? path.join(homeDir, "AppData", "Local", "Cache") : path.join(homeDir, ".cache"),
+      ">Config": platform === "win32" ? path.join(homeDir, "AppData", "Local", "Config") : "/etc",
+      ">CurrentDirectory": process.cwd(),
+      ">Home": homeDir
+    };
+    let resolvedPath = inputPath;
+    Object.keys(folderMappings).forEach(shortcut => {
+      if (resolvedPath.includes(shortcut)) {
+        const replacementPath = folderMappings[shortcut];
+        if (fs.existsSync(replacementPath)) {
+          resolvedPath = resolvedPath.replace(shortcut, replacementPath);
+        } else {
+          console.log(`The directory for '${shortcut}' does not exist on this system.`);
+          resolvedPath = resolvedPath.replace(shortcut, homeDir);
+        }
+      }
+    });
+    resolvedPath = this.osPath(resolvedPath);
+    resolvedPath = this.normalizePath(resolvedPath);
+    return resolvedPath;
+  }
 
   /**
    * Normalizes the input path to handle both single and double slashes.
@@ -48,7 +88,7 @@ class FileUtilityManager {
    * @returns {Array} - An array of objects containing file data, name, and path.
    */
   static getDirectoryData(inputDirPath) {
-    const dirPath = this.normalizePath(inputDirPath);
+    const dirPath = this.getTidePath(inputDirPath);
     if (!fs.existsSync(dirPath)) {
       console.log(`Directory at path ${dirPath} not found.`);
       return [];
@@ -76,10 +116,10 @@ class FileUtilityManager {
   /**
    * 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.
+   * @returns {Object|null} - An object containing file data, name, path, and size or null if the file doesn't exist.
    */
   static getFileData(inputFilePath) {
-    const filePath = this.normalizePath(inputFilePath);
+    const filePath = this.getTidePath(inputFilePath);
     if (!fs.existsSync(filePath)) {
       console.log(`File at path ${filePath} not found.`);
       return null;
@@ -89,6 +129,7 @@ class FileUtilityManager {
     });
     const fileName = path.basename(filePath);
     return {
+      size: fileData.length,
       fileName,
       fileData,
       filePath
@@ -101,7 +142,7 @@ class FileUtilityManager {
    * @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);
+    const currentInputPath = this.getTidePath(inputPath);
     if (!fs.existsSync(currentInputPath)) {
       console.log(`Path at ${currentInputPath} not found.`);
       return null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trap_stevo/filetide",
-  "version": "0.0.25",
+  "version": "0.0.27",
   "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": {