@trap_stevo/filetide 0.0.47 → 0.0.48

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);

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.48",
   "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": {