@trap_stevo/filetide 0.0.47 → 0.0.49

package/dist/cjs/FileMessager.js

@@ -325,7 +325,7 @@ class FileMessager {
         ...data,
         transferType: "send"
       });
-      this.transferQueue.waitForData(data.transferID, () => this.currentTransferBarrierTransfers.get(data.transferID), [true, false], 100, 50000).then(accepted => {
+      this.transferQueue.waitForData(data.transferID, () => this.currentTransferBarrierTransfers.get(data.transferID), [true, false], 100, data.transferExpirationTime ? data.transferExpirationTime : 50000).then(accepted => {
         console.log(`[FileTide ~ Net Barrier] ~ Transfer ${accepted ? "accepted!" : "denied."}`);
         this.fileNet.emitToTide(senderClient.tideID, "transfer-barrier-response", accepted);
         this.currentTransferBarrierTransfers.delete(data.transferID);

package/dist/cjs/FileMessagerClient.js

@@ -67,8 +67,9 @@ class FileMessagerClient {
       });
     };
   }
-  async requestTransfer(clientID, senderID, filePath, destinationPath, filterContent = []) {
-    const transferAllowed = await this.allowedTransfer(clientID, senderID, destinationPath, "N/A", "requestSend");
+  async requestTransfer(clientID, senderID, filePath, destinationPath, filterContent = [], transferRequestExpirationTime = 30000) {
+    const transferContentType = FileUtilityManager.inferPathType(filePath);
+    const transferAllowed = await this.allowedTransfer(clientID, senderID, destinationPath, filePath, "N/A", transferContentType === "file" ? 1 : "N/A", transferContentType, "requestSend", transferRequestExpirationTime);
     if (!transferAllowed) {
       return;
     }
@@ -89,7 +90,7 @@ class FileMessagerClient {
     });
     return;
   }
-  async allowedTransfer(clientID, recipientID, filePath, fileSize, transferType = "send") {
+  async allowedTransfer(clientID, recipientID, filePath, originPath, fileSize, fileCount = 1, transferContentType = "file", transferType = "send", transferExpirationTime = 30000) {
     try {
       const currentDate = Date.now();
       const transferID = `${clientID}_${filePath}_${currentDate}`;
@@ -97,10 +98,16 @@ class FileMessagerClient {
         clientID,
         recipientID,
         transferID,
+        originPath,
         path: filePath,
         date: currentDate,
+        transferExpirationTime,
+        timeUntilTransferExpiration: transferExpirationTime,
+        itemCount: fileCount,
+        itemSize: fileSize,
+        transferContentType,
         transferType
-      }, 30000);
+      }, transferExpirationTime);
       if (!transferAccepted) {
         FileNetUtilityManager.outputGradient(`[FileTide ~ File Messager] ${recipientID} denied your transfer.`, errorMessageColors);
         return false;
@@ -124,12 +131,13 @@ class FileMessagerClient {
    * @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.
-   * @param {Number} tideSize - The tide size in sending files (500)
-   * @param {Number} minTideSize - The minimum tide size in sending files (10)
-   * @param {Number} maxTideSize - The maximum tide size in sending files (2000)
+   * @param {string} destinationPath - The path to which the files should get sent.
+   * @param {Number} tideSize - The tide size in sending files (500).
+   * @param {Number} minTideSize - The minimum tide size in sending files (10).
+   * @param {Number} maxTideSize - The maximum tide size in sending files (2000).
+   * @param {Number} transferRequestExpirationTime - The maximum time until the transfer barrier times out the transfer request.
    */
-  async sendDirectoryFiles(clientID, recipientId, filesData, baseDirectory, destinationPath, tideSize = 500, minTideSize = 10, maxTideSize = 2000) {
+  async sendDirectoryFiles(clientID, recipientId, filesData, baseDirectory, destinationPath, tideSize = 500, minTideSize = 10, maxTideSize = 2000, transferRequestExpirationTime = 30000) {
     try {
       const baseDirectoryName = path.basename(baseDirectory);
       const adjustedDestinationPath = FileUtilityManager.normalizePath(path.join(destinationPath, baseDirectoryName));
@@ -138,7 +146,7 @@ class FileMessagerClient {
         totalSize += fileInfo.size;
       });
       const incomingType = this.activeTransferTypes.get(destinationPath);
-      const transferAllowed = incomingType && incomingType === "requestedTransfer" ? true : await this.allowedTransfer(clientID, recipientId, adjustedDestinationPath, totalSize, "send");
+      const transferAllowed = incomingType && incomingType === "requestedTransfer" ? true : await this.allowedTransfer(clientID, recipientId, adjustedDestinationPath, baseDirectory, totalSize, filesData.length, "directory", "send", transferRequestExpirationTime);
       if (incomingType) {
         this.activeTransferTypes.delete(destinationPath);
       }
@@ -149,23 +157,23 @@ class FileMessagerClient {
         const relativeFilePath = path.dirname(path.relative(baseDirectory, fileInfo.filePath));
         const fileDestinationPath = FileUtilityManager.normalizePath(path.join(adjustedDestinationPath, relativeFilePath));
         if (fileInfo.largeFile) {
-          return await this.sendDirectoryLargeFile(clientID, recipientId, fileInfo.fileName, fileInfo.filePath, fileDestinationPath, fileInfo.fileSize, index, tideSize, minTideSize, maxTideSize);
+          return await this.sendDirectoryLargeFile(clientID, recipientId, fileInfo.fileName, fileInfo.filePath, fileDestinationPath, fileInfo.fileSize, index, tideSize, minTideSize, maxTideSize, transferRequestExpirationTime);
         }
-        return await this.sendDirectoryFile(clientID, recipientId, fileInfo.fileName, fileInfo.filePath, fileInfo.size, fileDestinationPath, index, tideSize, minTideSize, maxTideSize);
+        return await this.sendDirectoryFile(clientID, recipientId, fileInfo.fileName, fileInfo.filePath, fileInfo.size, fileDestinationPath, index, tideSize, minTideSize, maxTideSize, transferRequestExpirationTime);
       });
       Promise.all(sendFilePromises).then(() => console.log("\nAll files in directory transferred successfully!")).catch(error => console.error("Did not transfer directory: ", error));
     } catch (error) {
       FileNetUtilityManager.outputGradient(`[FileTide ~ File Messager] ~ Refused directory transfer: ${error}`, errorMessageColors);
     }
   }
-  async sendDirectoryLargeFile(clientID, recipientId, fileName, filePath = process.cwd(), destinationPath = null, fileSize, index = 0, tideSize = 500, minTideSize = 10, maxTideSize = 2000) {
+  async sendDirectoryLargeFile(clientID, recipientId, fileName, filePath = process.cwd(), destinationPath = null, fileSize, index = 0, tideSize = 500, minTideSize = 10, maxTideSize = 2000, transferRequestExpirationTime = 30000) {
     let initiatingTransfer = false;
     if (index === 0) {
       initiatingTransfer = true;
     }
-    return await this.sendFile(clientID, recipientId, fileName, filePath, destinationPath, fileSize, tideSize, minTideSize, maxTideSize, initiatingTransfer, true, true, true);
+    return await this.sendFile(clientID, recipientId, fileName, filePath, destinationPath, fileSize, tideSize, minTideSize, maxTideSize, initiatingTransfer, true, true, true, transferRequestExpirationTime);
   }
-  async sendDirectoryFile(clientID, recipientId, fileName, filePath = process.cwd(), fileSize, directoryPath = null, index = 0, tideSize = 200, minTideSize = 10, maxTideSize = 2000) {
+  async sendDirectoryFile(clientID, recipientId, fileName, filePath = process.cwd(), fileSize, directoryPath = null, index = 0, tideSize = 200, minTideSize = 10, maxTideSize = 2000, transferRequestExpirationTime = 30000) {
     if (!filePath) {
       return;
     }
@@ -180,14 +188,14 @@ class FileMessagerClient {
       });
       initiatingTransfer = true;
     }
-    return await this.sendFile(clientID, recipientId, fileName, filePath, directoryPath, fileSize, tideSize, minTideSize, maxTideSize, initiatingTransfer, true, true, false);
+    return await this.sendFile(clientID, recipientId, fileName, filePath, directoryPath, fileSize, tideSize, minTideSize, maxTideSize, initiatingTransfer, true, true, false, transferRequestExpirationTime);
   }
-  async sendFile(clientID, recipientId, fileName, filePath = process.cwd(), destination = process.cwd(), fileSize, tideSize = 500, minTideSize = 10, maxTideSize = 2000, initiatingTransfer = true, inDirectory = false, largeFile = false) {
+  async sendFile(clientID, recipientId, fileName, filePath = process.cwd(), destination = process.cwd(), fileSize, tideSize = 500, minTideSize = 10, maxTideSize = 2000, initiatingTransfer = true, inDirectory = false, largeFile = false, transferRequestExpirationTime = 30000) {
     const destinationPath = FileUtilityManager.normalizePath(path.join(destination, fileName));
     FileNetUtilityManager.outputGradient(largeFile ? `[FileTide ~ File Messager] ~ Requesting to transfer large file ~ ${destinationPath} to ${recipientId}!` : `[FileTide ~ File Messager] ~ Requesting to transfer ~ ${destinationPath} to ${recipientId}!`, significantMessageColors);
     const incomingType = this.activeTransferTypes.get(filePath);
     if (!inDirectory && initiatingTransfer) {
-      const transferAllowed = incomingType && incomingType === "requestedTransfer" ? true : await this.allowedTransfer(clientID, recipientId, destinationPath, fileSize, "send");
+      const transferAllowed = incomingType && incomingType === "requestedTransfer" ? true : await this.allowedTransfer(clientID, recipientId, destinationPath, filePath, fileSize, 1, "file", "send", transferRequestExpirationTime);
       if (incomingType) {
         this.activeTransferTypes.delete(filePath);
       }

package/dist/cjs/FileTide.js

@@ -176,16 +176,17 @@ class FileTide {
 
   /**
    * Send files / directories directly to a device.
-   * @param {String} recipientID - The ID of the client device to send the data to
-   * @param {Buffer} fileData - The path of the data to send
-   * @param {String} destinationPath - The destination path on the device
-   * @param {Array} filterDirectoryContent - List of paths to filter
-   * @param {Number} tideSize - The tide size in sending smaller to medium files (200)
-   * @param {Number} tidalSize - The tide size in sending large files (500)
-   * @param {Number} minTideSize - The minimum tide size in sending files (10)
-   * @param {Number} maxTideSize - The maximum tide size in sending files (2000)
+   * @param {String} recipientID - The ID of the client device to send the data to.
+   * @param {Buffer} fileData - The path of the data to send.
+   * @param {String} destinationPath - The destination path on the device.
+   * @param {Array} filterDirectoryContent - List of paths to filter.
+   * @param {Number} tideSize - The tide size in sending smaller to medium files (200).
+   * @param {Number} tidalSize - The tide size in sending large files (500).
+   * @param {Number} minTideSize - The minimum tide size in sending files (10).
+   * @param {Number} maxTideSize - The maximum tide size in sending files (2000).
+   * @param {Number} transferRequestExpirationTime - The maximum time until the transfer barrier times out the transfer request.
    */
-  async sendToDevice(recipientID, filePath, destinationPath, filterDirectoryContent = [], tideSize = 200, tidalSize = 500, minTideSize = 10, maxTideSize = 2000) {
+  async sendToDevice(recipientID, filePath, destinationPath, filterDirectoryContent = [], tideSize = 200, tidalSize = 500, minTideSize = 10, maxTideSize = 2000, transferRequestExpirationTime = 30000) {
     const clientID = this.currentUserID;
     const clientMessager = this.clients.get(clientID);
     if (!clientMessager) {
@@ -207,16 +208,16 @@ class FileTide {
     if (fileDetails.type === "file") {
       if (fileDetails.largeFile) {
         FileTide.outputGradient(`[${clientID}] Sending large file ~ ${fileDetails.fileName} to client ~ ${recipientID}...`, ["#00C897", "#00E0FF"]);
-        await clientMessager.sendFile(clientID, recipientID, fileDetails.fileName, fileDetails.filePath, destinationPath, fileDetails.fileSize, tidalSize, minTideSize, maxTideSize, true, false, true);
+        await clientMessager.sendFile(clientID, recipientID, fileDetails.fileName, fileDetails.filePath, destinationPath, fileDetails.fileSize, tidalSize, minTideSize, maxTideSize, true, false, true, transferRequestExpirationTime);
         return true;
       }
       FileTide.outputGradient(`[${clientID}] Sending file ~ ${fileDetails.content.fileName} to client ~ ${recipientID}...`, ["#00C897", "#00E0FF"]);
-      await clientMessager.sendFile(clientID, recipientID, fileDetails.content.fileName, fileDetails.content.filePath, destinationPath, fileDetails.content.size, tideSize, minTideSize, maxTideSize);
+      await clientMessager.sendFile(clientID, recipientID, fileDetails.content.fileName, fileDetails.content.filePath, destinationPath, fileDetails.content.size, tideSize, minTideSize, maxTideSize, transferRequestExpirationTime);
       return true;
     }
     if (fileDetails.type === "directory") {
       FileTide.outputGradient(`[${clientID}] Sending ${fileDetails.content.length} files in directory ~ ${path.basename(filePath)} to client ~ ${recipientID}...`, ["#00C897", "#00E0FF"]);
-      await clientMessager.sendDirectoryFiles(clientID, recipientID, fileDetails.content, this.getTidePath(filePath), destinationPath, tideSize, minTideSize, maxTideSize);
+      await clientMessager.sendDirectoryFiles(clientID, recipientID, fileDetails.content, this.getTidePath(filePath), destinationPath, tideSize, minTideSize, maxTideSize, transferRequestExpirationTime);
       return true;
     }
     FileTide.outputGradient(`[FileTide] ~ No active client ~ ${recipientID} found.`, errorMessageColors);
@@ -434,7 +435,11 @@ function _setupFileEventListeners(userID, client, onTransferProgress, onIncoming
         });
       }
       if (onIncomingFile) {
-        onIncomingFile(verifiedSender, data, fileTransferReceiver.activeTransfers);
+        const taskBarStats = this.progressBarManager.getTaskBar(data.fileName);
+        onIncomingFile(verifiedSender, {
+          ...data,
+          stats: taskBarStats
+        }, fileTransferReceiver.activeTransfers);
       }
       if (verifiedSender && !fs.existsSync(saveDir)) {
         fs.mkdirSync(saveDir, {
@@ -470,7 +475,11 @@ function _setupFileEventListeners(userID, client, onTransferProgress, onIncoming
     currentTransferState.transferredSize += data.chunkSize || 512 * 1024;
     FileTransferRecoveryManager.saveTransferState(userID, data.senderName, `${data.path}-${data.fileName}`, data.chunkIndex, currentTransferState.transferredSize);
     if (onTransferProgress) {
-      onTransferProgress(data);
+      const taskBarStats = this.progressBarManager.getTaskBar(data.fileName);
+      onTransferProgress({
+        ...data,
+        stats: taskBarStats
+      });
     }
   });
   client.clientTide.onEvent(userID, "transfer-status", data => {
@@ -488,7 +497,11 @@ function _setupFileEventListeners(userID, client, onTransferProgress, onIncoming
     }
     this.progressBarManager.updateTaskProgress(fileName, chunkSize);
     if (onTransferStatus) {
-      onTransferStatus(data);
+      const taskBarStats = this.progressBarManager.getTaskBar(fileName);
+      onTransferStatus({
+        ...data,
+        stats: taskBarStats
+      });
     }
     return;
   });
@@ -508,13 +521,21 @@ function _setupFileEventListeners(userID, client, onTransferProgress, onIncoming
           _FileTide.outputGradient(`[${userID}] Did not save file at : ${savePath}\n\t${error}\n`, errorMessageColors);
         }
         if (onTransferComplete) {
-          onTransferComplete(data, fileTransferReceiver.activeTransfers, success);
+          const taskBarStats = this.progressBarManager.getTaskBar(data.fileName);
+          onTransferComplete({
+            ...data,
+            stats: taskBarStats
+          }, fileTransferReceiver.activeTransfers, success);
         }
       });
     } catch (error) {
       _FileTide.outputGradient(`[${userID}] Did not save file at : ${savePath}\n${error}`, errorMessageColors);
       if (onTransferComplete) {
-        onTransferComplete(data, fileTransferReceiver.activeTransfers, false);
+        const taskBarStats = this.progressBarManager.getTaskBar(data.fileName);
+        onTransferComplete({
+          ...data,
+          stats: taskBarStats
+        }, fileTransferReceiver.activeTransfers, false);
       }
     }
   });

package/dist/cjs/HUDComponents/ConsoleProgressBarManager.js

@@ -4,7 +4,8 @@ const readline = require("readline");
 const chalk = require("chalk");
 class ConsoleProgressBarManager {
   constructor(tasks = [], options = {}) {
-    this.visibleBars = process.stdout.rows - 3;
+    const rows = process.stdout.rows || 24;
+    this.visibleBars = rows - 3;
     this.currentPage = 0;
     this.barsPerPage = this.visibleBars;
     this.maxCompletionFeedSize = 5;
@@ -107,8 +108,10 @@ class ConsoleProgressBarManager {
         };
       },
       redraw: () => {
-        readline.cursorTo(process.stdout, 0, newBar.taskIndex % this.barsPerPage);
-        process.stdout.clearLine();
+        if (!isNaN(newBar.taskIndex) && !isNaN(this.barsPerPage)) {
+          readline.cursorTo(process.stdout, 0, newBar.taskIndex % this.barsPerPage);
+          process.stdout.clearLine();
+        }
         if (newBar.completed) {
           process.stdout.write(settings.taskCompletedColor(`${newBar.taskName}: Completed!`));
           return;
@@ -167,6 +170,9 @@ class ConsoleProgressBarManager {
           this.exitInputListener();
           this.displayPage();
           this.displayCompletionMessage();
+          setTimeout(() => {
+            this.clearTaskBars();
+          }, this.completionTimeout);
         }
       }
     };
@@ -202,6 +208,55 @@ class ConsoleProgressBarManager {
       console.log(chalk.red(`Task ${taskName} not found.`));
     }
   }
+  getCurrentStats() {
+    const completedTasks = this.taskBars.filter(bar => bar.completed).length;
+    const totalTasks = this.taskBars.length;
+    const overallProgress = this.taskBars.reduce((acc, bar) => acc + bar.current / bar.totalSize * 100, 0) / totalTasks;
+    const stats = {
+      completedTasks,
+      totalTasks,
+      overallProgress: `${overallProgress.toFixed(2)}%`,
+      taskDetails: this.taskBars.map(bar => ({
+        taskName: bar.taskName,
+        progress: `${(bar.current / bar.totalSize * 100).toFixed(2)}%`,
+        completed: bar.completed,
+        currentSize: bar.getFormattedSize(bar.current),
+        totalSize: bar.getFormattedSize(bar.totalSize),
+        speed: `${bar.getUnitData(bar.speed).current} ${bar.getUnitData(bar.speed).unit}/s`,
+        timeLeft: this.convertSeconds(bar.timeLeft.toFixed(2))
+      }))
+    };
+    return stats;
+  }
+  getTaskBar(taskID) {
+    if (typeof taskID === "string") {
+      return this.taskBars.find(bar => bar.taskName === taskID) || null;
+    } else if (typeof taskID === "number") {
+      return this.taskBars[taskID] || null;
+    }
+    return null;
+  }
+  clearTaskBars() {
+    this.taskBars = [];
+    this.totalTasks = 0;
+    this.completedTasksCount = 0;
+    this.completionFeed = [];
+    this.allTasksCompleted = false;
+  }
+  clearTaskBar(taskID) {
+    let taskIndex = null;
+    if (typeof taskID === "string") {
+      taskIndex = this.taskBars.findIndex(bar => bar.taskName === taskID);
+    } else if (typeof taskID === "number") {
+      taskIndex = identifier;
+    }
+    if (taskIndex !== null && taskIndex >= 0 && taskIndex < this.taskBars.length) {
+      this.taskBars.splice(taskIndex, 1);
+      this.totalTasks--;
+      return true;
+    }
+    return false;
+  }
   clearPage() {
     for (let i = 0; i < this.barsPerPage + 2; i++) {
       readline.cursorTo(process.stdout, 0, i);
@@ -221,21 +276,27 @@ class ConsoleProgressBarManager {
   }
   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();
+    if (!isNaN(bottomPosition)) {
+      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 (!isNaN(bottomPosition)) {
+      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();
+    if (!isNaN(this.barsPerPage)) {
+      process.stdin.setRawMode(true);
+      process.stdin.resume();
+    }
     process.stdin.setEncoding("utf-8");
     this.inputListener = key => {
       if (key === "\u0003") {

package/dist/cjs/HUDManagers/FileUtilityManager.js

@@ -211,6 +211,19 @@ class FileUtilityManager {
     return stats.isDirectory();
   }
 
+  /**
+   * Determines the type of a given path (directory or file) based on conventions.
+   * @param {string} inputPath - The path to infer.
+   * @returns {string} - Returns "directory" if the path has no extension, "file" if it contains an extension.
+   */
+  static inferPathType(inputPath) {
+    const parsedPath = path.parse(inputPath);
+    if (parsedPath.ext) {
+      return "file";
+    }
+    return "directory";
+  }
+
   /**
    * Helper function to check if a path exists.
    * @param {string} inputPath - The path to check.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trap_stevo/filetide",
-  "version": "0.0.47",
+  "version": "0.0.49",
   "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": {
@@ -10,6 +10,10 @@
     "start": "node dist/cjs/FileTide.js"
   },
   "keywords": [
+    "Legendary",
+    "Enlightened",
+    "Steven Compton",
+    "Magical",
     "real-time",
     "nodejs",
     "ota",