@trap_stevo/filetide/dist/cjs/HUDManagers/FileTransferReceiverManager.js

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 wi

"use strict";

const path = require("path");
const fs = require("fs");
const {
  FileTransferTrackingManager
} = require("./FileTransferTrackingManager.js");
const {
  FileTideDebugUtilityManager
} = require("./FileTideDebugUtilityManager.js");
const {
  FileUtilityManager
} = require("./FileUtilityManager.js");
class FileTransferReceiverManager {
  constructor() {}
  async initializeTransfer(data, onError) {
    const savePath = FileUtilityManager.getTidePath(path.join(data.path || data.filePath, data.fileName));
    FileTideDebugUtilityManager.log("notice", true, `Initializing transfer ~ ${data.fileName} | ${savePath}...`);
    if (FileTransferTrackingManager.containsTransfer(data.fileName)) {
      FileTideDebugUtilityManager.log("notice", true, `Transfer ~ ${data.fileName} | ${savePath} already initialized.`);
      return;
    }
    try {
      const dir = path.dirname(savePath);
      if (!fs.existsSync(dir)) {
        fs.mkdirSync(dir, {
          recursive: true
        });
      }
      const fileStream = fs.createWriteStream(savePath, {
        flags: "w"
      });
      FileTransferTrackingManager.trackTransfer(data, fileStream);
      FileTideDebugUtilityManager.log("notice", true, `Initialized transfer ~ ${data.fileName} | ${savePath}!`);
    } catch (error) {
      FileTideDebugUtilityManager.log("error", true, `Did not initialize transfer ~ ${data.fileName} | ${savePath}.\n\t\t${error}`);
      if (onError) {
        onError(`[${data.fileName}] Did not initialize transfer ~ ${error.message}`);
      }
    }
  }
  async handleTransferProgress(data, onError) {
    let transferState = FileTransferTrackingManager.getTransfer(data.fileName);
    if (!transferState) {
      await this.initializeTransfer(data);
      transferState = tFileTransferTrackingManager.getTransfer(data.fileName);
    }
    const chunkBuffer = Buffer.from(data.fileChunk);
    try {
      transferState.fileStream.write(chunkBuffer);
      transferState.receivedChunks.add(data.chunkIndex);
    } catch (error) {
      FileTideDebugUtilityManager.log("error", true, `Did not write chunk ${data.chunkIndex} ~ ${data.fileName}.\n\t\t${error}`);
      if (onError) {
        onError(`[${data.fileName}] Did not write chunk ${data.chunkIndex} ~ ${error.message}`);
      }
    }
  }
  async completeTransfer(data, onComplete) {
    let transferState = FileTransferTrackingManager.getTransfer(data.fileName);
    FileTideDebugUtilityManager.log("notice", true, `Completing transfer ~ ${data.fileName}...`);
    if (!transferState) {
      FileTideDebugUtilityManager.log("notice", true, `Did not get transfer state ~ ${data.fileName}...re-initializing....`);
      await this.initializeTransfer(data);
      transferState = FileTransferTrackingManager.getTransfer(data.fileName);
    }
    try {
      FileTideDebugUtilityManager.log("notice", true, `Verifying transfer state ~ ${data.fileName} completion (${transferState.receivedChunks.size}/${transferState.totalChunks})...`);
      FileTideDebugUtilityManager.log("notice", true, `Transfer state ~ ${data.fileName} completed ~ (${transferState.receivedChunks.size === transferState.totalChunks}).`);
      if (transferState.receivedChunks.size === transferState.totalChunks) {
        transferState.fileStream.end();
        console.log(`[${data.fileName}] Transfer complete. All chunks received and file written.`);
        FileTransferTrackingManager.untrackTransfer(data.fileName);
        FileTideDebugUtilityManager.log("notice", true, `Cleared transfer state ~ ${data.fileName}.`);
        FileTransferTrackingManager.outputCurrentTransfers();
        if (onComplete) onComplete(data, FileTransferTrackingManager.activeTransfers, true);
      } else {
        FileTideDebugUtilityManager.log("error", true, `Transfer incomplete. Received ${transferState.receivedChunks.size}/${transferState.totalChunks} chunks.`);
        throw new Error(`[${data.fileName}] Transfer incomplete. Received ${transferState.receivedChunks.size}/${transferState.totalChunks} chunks.`);
      }
    } catch (error) {
      FileTideDebugUtilityManager.log("error", true, `Transfer incomplete.\n\t\t${error}`);
      if (onComplete) {
        onComplete(data, FileTransferTrackingManager.activeTransfers, false, error);
      }
    }
  }
}
module.exports = {
  FileTransferReceiverManager
};