@trap_stevo/filetide-client 0.0.0

package/dist/cjs/FileTideClient.js

@@ -0,0 +1,353 @@
+"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 {
+  HUDUtilityManager
+} = require("@trap_stevo/legendarybuilderpronodejs-utilities");
+const FileTide = require("@trap_stevo/filetide");
+const chalk = require("chalk");
+const path = require("path");
+const fs = require("fs");
+const os = require("os");
+let currentRoom = "file-room";
+let tideUrl = "http://localhost:9269";
+const deviceName = os.hostname();
+const fileTide = new FileTide();
+let fileMessagerInstance;
+const gradients = {
+  success: ["\x1b[38;5;48m", "\x1b[38;5;49m", "\x1b[38;5;50m"],
+  "indicator": ["\x1b[38;5;30m", "\x1b[38;5;37m", "\x1b[38;5;44m", "\x1b[38;5;51m", "\x1b[38;5;147m"],
+  error: ["\x1b[38;5;203m", "\x1b[38;5;202m", "\x1b[38;5;208m"],
+  info: ["\x1b[38;5;74m", "\x1b[38;5;75m"],
+  critical: ["\x1b[38;5;203m", "\x1b[38;5;214m"],
+  neutral: ["\x1b[38;5;74m", "\x1b[38;5;81m", "\x1b[38;5;117m", "\x1b[38;5;153m"]
+};
+const shortcuts = {
+  ">Downloads": {
+    description: "User's downloads folder.",
+    shortCut: ">Downloads"
+  },
+  ">Documents": {
+    description: "User's documents folder.",
+    shortCut: ">Documents"
+  },
+  ">Desktop": {
+    description: "User's desktop folder.",
+    shortCut: ">Desktop"
+  },
+  ">AppData": {
+    description: "User's roaming application data folder.",
+    shortCut: ">AppData"
+  },
+  ">LocalAppData": {
+    description: "User's local application data folder.",
+    shortCut: ">LocalAppData"
+  },
+  ">Music": {
+    description: "User's music folder.",
+    shortCut: ">Music"
+  },
+  ">Pictures": {
+    description: "User's pictures folder.",
+    shortCut: ">Pictures"
+  },
+  ">Videos": {
+    description: "User's videos folder.",
+    shortCut: ">Videos"
+  },
+  ">Public": {
+    description: "User's public folder.",
+    shortCut: ">Public"
+  },
+  ">Templates": {
+    description: "User's templates folder",
+    shortCut: ">Templates"
+  },
+  ">Temp": {
+    description: "System's temp folder.",
+    shortCut: ">Temp"
+  },
+  ">LogFiles": {
+    description: "System's logs folder.",
+    shortCut: ">LogFiles"
+  },
+  ">SystemRoot": {
+    description: "System's root folder.",
+    shortCut: ">SystemRoot"
+  },
+  ">Cache": {
+    description: "User's application cache folder.",
+    shortCut: ">Cache"
+  },
+  ">Config": {
+    description: "User's application config folder.",
+    shortCut: ">Config"
+  },
+  ">CurrentDirectory": {
+    description: "User's current folder.",
+    shortCut: ">CurrentDirectory"
+  },
+  ">Home": {
+    description: "System's home folder.",
+    shortCut: ">Home"
+  }
+};
+const colorReset = "\x1b[0m";
+var _FileTideClient_brand = /*#__PURE__*/new WeakSet();
+class FileTideClient {
+  constructor(inputDeviceName, inputTideURL, inputCurrentRoom, displayTitle = true, showCLITitle = false) {
+    _classPrivateMethodInitSpec(this, _FileTideClient_brand);
+    this.currentDeviceName = inputDeviceName || deviceName;
+    this.originDeviceName = inputDeviceName || deviceName;
+    this.deviceName = inputDeviceName || deviceName;
+    this.tideUrl = inputTideURL || tideUrl;
+    this.currentRoom = inputCurrentRoom || currentRoom;
+    this.fileMessagerInstance = fileMessagerInstance;
+    this.clientDisconnected = false;
+    this.shortcuts = shortcuts;
+    _assertClassBrand(_FileTideClient_brand, this, _setupProcessEvents).call(this);
+    if (displayTitle) {
+      this.displayTitle(showCLITitle);
+    }
+    return;
+  }
+  applyGradient(text, gradientType) {
+    const colors = gradients[gradientType];
+    let gradientText = "";
+    if (text.length === 0) return colorReset + text;
+    const totalSteps = Math.max(text.length - 1, 1);
+    for (let i = 0; i < text.length; i++) {
+      const progress = i / totalSteps;
+      const colorIndex = Math.floor(progress * (colors.length - 1));
+      gradientText += colors[colorIndex] + text[i];
+    }
+    return gradientText + colorReset;
+  }
+  displayMessage(type, message) {
+    switch (type) {
+      case "success":
+        console.log(this.applyGradient(message, "success"));
+        break;
+      case "indicator":
+        console.log(this.applyGradient(message, "indicator"));
+        break;
+      case "error":
+        console.log(this.applyGradient(message, "error"));
+        break;
+      case "info":
+        console.log(this.applyGradient(message, "info"));
+        break;
+      case "critical":
+        console.log(this.applyGradient(message, "critical"));
+        break;
+      case "neutral":
+        console.log(this.applyGradient(message, "neutral"));
+        break;
+      default:
+        console.log(this.applyGradient(message, "neutral"));
+    }
+  }
+  broadcastClientOffline(fileMessager) {
+    if (fileMessager && !this.clientDisconnected) {
+      this.clientDisconnected = true;
+      fileMessager.clientTide.emitEvent(this.currentDeviceName, "client-offline", this.currentDeviceName);
+      FileTide.outputGradient(`[${this.currentDeviceName}] Disconnected from the file net.`, ["#00C897", "#00E0FF"]);
+    }
+  }
+  startClient(clientOptions = {}, connectionOptions = {}, ...clientConfigurations) {
+    if (this.fileMessagerInstance && this.fileMessagerInstance.clientTide) {
+      this.fileMessagerInstance.clientTide.closeSocket(this.currentDeviceName);
+    }
+    fileTide.launchMessager({
+      serverUrl: this.tideUrl,
+      ...clientOptions
+    }, {
+      maxHttpBufferSize: 5e9,
+      pingTimeout: 3600000,
+      pingInterval: 60000,
+      ...connectionOptions
+    }, this.currentRoom, this.deviceName, fileMessager => {
+      this.fileMessagerInstance = fileMessager;
+      fileMessager.clientTide.onEvent(this.deviceName, "connect", () => {
+        this.clientDisconnected = false;
+        FileTide.outputGradient(`[${this.deviceName}] Connected to FileTide ~ ${this.tideUrl} in ${this.currentRoom}!`, ["#00C897", "#00E0FF"]);
+        fileMessager.clientTide.emitEvent(this.deviceName, "client-online", this.deviceName, fileMessager.clientTide.sockets[this.deviceName].tideID, this.pDeviceName, fileMessager.clientTide.sockets[this.deviceName].id);
+        FileTide.outputGradient(`[${this.currentDeviceName}] Getting connected clients...`, ["#00C897", "#00E0FF"]);
+      });
+      fileMessager.clientTide.onEvent(this.deviceName, "disconnect", () => {
+        this.broadcastClientOffline(fileMessager);
+      });
+    }, ...clientConfigurations);
+  }
+  requestFileTransfer(senderID, filePath, destinationPath) {
+    FileTide.outputGradient(`[${this.deviceName}] Requesting ${path.basename(filePath)} from client ~ ${senderID}...`, ["#00C897", "#00E0FF"]);
+    this.fileMessagerInstance.requestTransfer(this.deviceName, senderID, filePath, destinationPath);
+    return;
+  }
+  sendFileTransfer(recipientID, filePath, destinationPath) {
+    const fileDetails = fileTide.getPathData(filePath);
+    if (!fileDetails) {
+      FileTide.outputGradient(`[${this.deviceName}] File at path ${filePath} not found.`, ["#F94144", "#F3722C"]);
+      return;
+    }
+    if (fileDetails.type === "file") {
+      FileTide.outputGradient(`[${this.deviceName}] Sending file ~ ${fileDetails.content.fileName} to client ~ ${recipientID}...`, ["#00C897", "#00E0FF"]);
+      this.fileMessagerInstance.sendFile(this.deviceName, recipientID, fileDetails.content.fileName, fileDetails.content.fileData, destinationPath, fileDetails.content.size);
+      return;
+    }
+    if (fileDetails.type === "directory") {
+      FileTide.outputGradient(`[${this.deviceName}] Sending ${fileDetails.content.length} files in directory ~ ${path.basename(filePath)} to client ~ ${recipientID}...`, ["#00C897", "#00E0FF"]);
+      this.fileMessagerInstance.sendDirectoryFiles(this.deviceName, recipientID, fileDetails.content, fileTide.getTidePath(filePath), destinationPath);
+      return;
+    }
+    return;
+  }
+  addShortcuts(inputShortcuts) {
+    for (const [key, value] of Object.entries(inputShortcuts)) {
+      if (!shortcuts[key]) {
+        this.shortcuts[key] = {
+          description: value.description || "No description provided.",
+          shortCut: key
+        };
+      }
+    }
+    return shortcuts;
+  }
+  getShortcuts() {
+    return shortcuts;
+  }
+  getOnlineClients() {
+    this.fileMessagerInstance.clientTide.emitEvent(this.deviceName, "clients-online", this.deviceName);
+    return;
+  }
+  changeRoom(room) {
+    this.currentRoom = room;
+    FileTide.outputGradient(`[${this.deviceName}] Updated room to ${this.currentRoom}`, ["#4D96FF", "#89CFF0"]);
+    this.startClient();
+    return;
+  }
+  changeClientID(clientID) {
+    this.currentDeviceName = this.deviceName;
+    this.deviceName = clientID;
+    this.fileMessagerInstance.clientTide.emitEvent(this.currentDeviceName, "client-offline", this.currentDeviceName);
+    FileTide.outputGradient(`[${this.deviceName}] Updated client name to ${this.deviceName}`, ["#4D96FF", "#89CFF0"]);
+    this.startClient();
+    return;
+  }
+  changeTideUrl(url) {
+    this.tideUrl = url;
+    FileTide.outputGradient(`[${this.deviceName}] Updated tide URL to ${this.tideUrl}`, ["#4D96FF", "#89CFF0"]);
+    this.startClient();
+    return;
+  }
+  displayTitle(cli = false) {
+    FileTide.outputGradient(`
+             ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+             ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+             ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+             ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+             ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+             ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+             ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+             ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+             ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+             ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+             ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+             ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+             ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::::::;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+             ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:;:::::;;;;:::::::;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+             ;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::::;+?%%%%%%%?*;::::::::::::;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+             ;;;;;;;;;;;;;;;;;;;;;;;;;;;:::;*%%?+;:,,,::+?S?;:::::::::::::::::;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+             ;;;;;;;;;;;;;;;;;;;;;;;;::::;*S?;,,,,::::::,,;SS;:::;+++++++++;;:::::::;;;;;;:::::::;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+             ;;;;;;;;;;;;;;;;;;;;;;;;:::+S%:.,::;::;;+++;::*@+:*SSS%%%%%%%%SS%+:::::::::::::::::::::;::;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+             ;;;;;;;;;;;;;;;;;;;;;;;;;:+#*,,:;;::+?SSSSS#?+SS+SS;:,,,,,,,,,,;S#?;::::::::::::::::::::::::;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+             ;;;;;;;;;;;;;;;;;;;;;;;;:;S?.,;;;:;%#%*+;*S##SS%S*,:;;;;;;;;;;;:,+S#%%%%%%%%%%%%%%%%%%%%%?+::::;;;;;;;;;;;;;;;;;;;;;;;;;
+             ;;;;;;;;;;;;;;;;;;;;;;;;:?#:,;;;:;S#*;::?#%+++%#*.:;;;;;;;;;;;;;;::;++++++++++++++++++++*?#S+::;;;;;;;;;;;;;;;;;;;;;;;;;
+             ;;;;;;;;;;;;;;;;;;;;;;;;;S%,;;;;;%#*;::*#?:::;S#+;+++++++++++++++++++++++++;;;;;;;;;;;;;;;;##;:;;;;;;;;;;;;;;;;;;;;;;;;;
+             ;;;;;;;;;;;;;;;;;;;;;;;:;#%:;;;;*#?+::;#S:::::S#*%%SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSS?S#;::;;;;;;;;;;;;;;;;;;;;;;;;
+             ;;;;;;;;;;;;;;;;;;;;;;;:;S%;+;;;%#*+::+#%:::::S#S?+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+%##;::;;;;;;;;;;;;;;;;;;;;;;;;
+             ;;;;;;;;;;;;;;;;;;;;;;;:;SS++;;;%#**::+#?::::;#S:,,:::::::::::::::::::::::::::::::::::::::,+#%::;;;;;;;;;;;;;;;;;;;;;;;;
+             ;;;;;;;;;;;;;;;;;;;;;;::;SS?*+;;%#?*;:;#S::::+#?,;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;,S#;:::::;;;;;;;;;;;;;;;;;;;;
+             ;;;;;;;;;;;;;;;;;;;;;;;:;S#S*+;;*#%*+::?#*:::+#?,;;;;;;;;;**;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:S#;::::;;;;;;;;;;;;;;;;;;;;;
+             ;;;;;;;;;;;;;;;;;;;;;;::;S##?*;;;SS**;::%#*::+#?,;;;;;;;;;++;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:S#;::::;;;;;;;;;;;;;;;;;;;;;
+             ;;;;;;;;;;;;;;;;;;;;;;::;S##S**;;*#%**;;:?#?:;#?,+++++++++;;+++++++++++++++++++++++++++++++;S#;:::::;;;;;;;;;;;;;;;;;;;;
+             ;;;;;;;;;;;;;;;;;;;;;;::;S%?#?*+;;?#%**;;:*#S?#%:*++++++++++++++++++++++++++++++++++++++++*+S#;:::;;;;;;;;;;;;;;;;;;;;;;
+             ;;;;;;;;;;;;;;;;;;;;;;::;S%:SS?*+;;?#%**+;;;?##S;******************************************+S#;::::;;;;;;;;;;;;;;;;;;;;;
+             ;;;;;;;;;;;;;;;;;;;;;:::;SS,;#S??+;;*#S?*+;;:;?##%?******??%%SSSSSSS%%??********************##;::::::;;;;;;;;;;;;;;;;;;;
+             ;;;;;;;;;;;;;;;;;;;;;;::;SS;,;#S??+;;;%#S?*+;;;;?S#S%??%SS?*+;:::::;+*%SSS%%????????????????##;::::::;;;;;;;;;;;;;;;;;;;
+             ;;;;;;;;;;;;;;;;;;;;;;::;SS;;,:S#??*+;;+%#S%?*++;;+?##S*;,,,,:::::::,,,,;?##SSSS%%%???????%%##;::::;;;;;;;;;;;;;;;;;;;;;
+             ;;;;;;;;;;;;;;;;;;;;;;::;SS*+;:,*#S??*+;;+?S#S%?**?SS+,,::;;;;;::::;;;;::,:?#%**?%SSSSSSSSS%%S;:::;;;;;;;;;;;;;;;;;;;;;;
+             ;;;;;;;;;;;;;;;;;;;;;;::;S#%**+;,:?SS%?**+;;+?S###%+,,:;;;;;;+**???**;;;;;:,;%#S*;;;;;;;;;::?S;:::;;;;;;;;;;;;;;;;;;;;;;
+             ;;;;;;;;;;;;;;;;;;;;;;::;S##S?*++;::*%SSSSS%%%S%*:,,:;;;;;;*%SS%???%SSS?*+;;:,;%##%?**+++++*S#;:::;;;;;;;;;;;;;;;;;;;;;;
+             ;;;;;;;;;;;;;;;;;;;;;;;:;SS;%#%?*++;:::;++**+;:,,:;;;;;;;;%#?+;;;;;;;;*%SS?*+;;::+?%SSSSSSSSS#;:::;;;;;;;;;;;;;;;;;;;;;;
+             ;;;;;;;;;;;;;;;;;;;;;;::;SS;:+S#S?**++;;;:::::;;;;;+*+++;*S?+++++++;;;;;;*S#%**+;;:::;;;;;;:*S;:::;;;;;;;;;;;;;;;;;;;;;;
+             ;;;;;;;;;;;;;;;;;;;;;;;:;SS*+;;+?SSS%?**+++++++**?%S%+;;?#?*???????**++;;;;*%SS%?**++;;;;;;;%S;:::;;;;;;;;;;;;;;;;;;;;;;
+             ;;;;;;;;;;;;;;;;;;;;;;;::?#%?*++;;+*%SSSSS%%%%SSS%?+;;+%#SSSSSSSSSSS%%?**++;;;*%SSSS%%????%%#S;:::;;;;;;;;;;;;;;;;;;;;;;
+             ;;;;;;;;;;;;;;;;;;;;;;;;::%#%??**++;;;;+**???**++;;;+?S#S%%???**++*?%SSS%?**+++;;++*?%%%%%%##+:::;;;;;;;;;;;;;;;;;;;;;;;
+             ;;;;;;;;;;;;;;;;;;;;;;;;;::*##%???****+++;;;;;;+++*?S#S%??????***+++++*%SSS%??****+++++++*%S+:::;;;;;;;;;;;;;;;;;;;;;;;;
+             ;;;;;;;;;;;;;;;;;;;;;;;;;;::;?S#SS%?????******??%%SSS%%%%SSSS%%%%????****?%SSSS%%??????%S#?;::::;;;;;;;;;;;;;;;;;;;;;;;;
+             ;;;;;;;;;;;;;;;;;;;;;;;;;;;:::;+?%S##SSSSSSSSS#####SSSSS#SS#######SSSSSSSSSSS#######SSS%*;::::;;;;;;;;;;;;;;;;;;;;;;;;;;
+             ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::;+++********************************************+++;;::::::;;;;;;;;;;;;;;;;;;;;;;;;;;;
+             ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::::::::::::::::::::::::::::::::::::::::::::::::::::::;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+             ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::::::::::::::::::::::::::;;;::::::::::::;;;;;;;;:;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+             ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::::;::::::::::;;:;;;;;;;;;;::;;:::;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+             ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::::::;;;;;:;;;;;;;;;;;;;;;::;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+             ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+             ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+             ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+             ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+             ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+             ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+             ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+             ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+             ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+             ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+          `, ["#0077B6", "#00B4D8"]);
+    if (cli) {
+      FileTide.outputGradient(`
+          \t\t _______  ___   ___      _______  _______  ___   ______   _______       _______  ___      ___  
+          \t\t|       ||   | |   |    |       ||       ||   | |      | |       |     |       ||   |    |   | 
+          \t\t|    ___||   | |   |    |    ___||_     _||   | |  _    ||    ___|     |       ||   |    |   | 
+          \t\t|   |___ |   | |   |    |   |___   |   |  |   | | | |   ||   |___      |       ||   |    |   | 
+          \t\t|    ___||   | |   |___ |    ___|  |   |  |   | | |_|   ||    ___|     |      _||   |___ |   | 
+          \t\t|   |    |   | |       ||   |___   |   |  |   | |       ||   |___      |     |_ |       ||   | 
+          \t\t|___|    |___| |_______||_______|  |___|  |___| |______| |_______|     |_______||_______||___|                                                                                     
+          `, ["#028090", "#56cfe1"]);
+    } else if (!cli) {
+      FileTide.outputGradient(`
+          \t\t\t\t _______  ___   ___      _______  _______  ___   ______   _______
+          \t\t\t\t|       ||   | |   |    |       ||       ||   | |      | |       | 
+          \t\t\t\t|    ___||   | |   |    |    ___||_     _||   | |  _    ||    ___| 
+          \t\t\t\t|   |___ |   | |   |    |   |___   |   |  |   | | | |   ||   |___ 
+          \t\t\t\t|    ___||   | |   |___ |    ___|  |   |  |   | | |_|   ||    ___| 
+          \t\t\t\t|   |    |   | |       ||   |___   |   |  |   | |       ||   |___
+          \t\t\t\t|___|    |___| |_______||_______|  |___|  |___| |______| |_______|                                                                                   
+          `, ["#028090", "#56cfe1"]);
+    }
+    FileTide.outputGradient(`
+           ▄▄· ▄▄▄  ▄▄▄ . ▄▄▄· ▄▄▄▄▄▄▄▄ .·▄▄▄▄      ▄▄▄▄·  ▄· ▄▌    .▄▄ · ▄▄▄▄▄▄▄▄ . ▌ ▐·▄▄▄ . ▐ ▄      ▄▄·       • ▌ ▄ ·.  ▄▄▄·▄▄▄▄▄       ▐ ▄ 
+          ▐█ ▌▪▀▄ █·▀▄.▀·▐█ ▀█ •██  ▀▄.▀·██▪ ██     ▐█ ▀█▪▐█▪██▌    ▐█ ▀. •██  ▀▄.▀·▪█·█▌▀▄.▀·•█▌▐█    ▐█ ▌▪▪     ·██ ▐███▪▐█ ▄█•██  ▪     •█▌▐█
+          ██ ▄▄▐▀▀▄ ▐▀▀▪▄▄█▀▀█  ▐█.▪▐▀▀▪▄▐█· ▐█▌    ▐█▀▀█▄▐█▌▐█▪    ▄▀▀▀█▄ ▐█.▪▐▀▀▪▄▐█▐█•▐▀▀▪▄▐█▐▐▌    ██ ▄▄ ▄█▀▄ ▐█ ▌▐▌▐█· ██▀· ▐█.▪ ▄█▀▄ ▐█▐▐▌
+          ▐███▌▐█•█▌▐█▄▄▌▐█ ▪▐▌ ▐█▌·▐█▄▄▌██. ██     ██▄▪▐█ ▐█▀·.    ▐█▄▪▐█ ▐█▌·▐█▄▄▌ ███ ▐█▄▄▌██▐█▌    ▐███▌▐█▌.▐▌██ ██▌▐█▌▐█▪·• ▐█▌·▐█▌.▐▌██▐█▌
+          ·▀▀▀ .▀  ▀ ▀▀▀  ▀  ▀  ▀▀▀  ▀▀▀ ▀▀▀▀▀•     ·▀▀▀▀   ▀ •      ▀▀▀▀  ▀▀▀  ▀▀▀ . ▀   ▀▀▀ ▀▀ █▪    ·▀▀▀  ▀█▄▀▪▀▀  █▪▀▀▀.▀    ▀▀▀  ▀█▄▀▪▀▀ █▪
+          `, ["#1a73e8", "#a0c4ff"]);
+  }
+}
+function _setupProcessEvents() {
+  process.on("exit", code => {
+    FileTide.outputGradient(`Exited FileTide: ${code}`, ["#00C897", "#00E0FF"]);
+    this.broadcastClientOffline(this.fileMessagerInstance);
+  });
+  process.on("SIGINT", () => {
+    FileTide.outputGradient("Exiting FileTide (Ctrl+C).", ["#00C897", "#00E0FF"]);
+    process.exit();
+  });
+  process.on("uncaughtException", error => {
+    FileTide.outputGradient(`Uncaught exception: ${error}`, ["#F94144", "#F3722C"]);
+    process.exit(1);
+  });
+}
+;
+module.exports = FileTideClient;

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/filetide-cli.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+"use strict";
+
+const FileTideClient = require("./FileTideClient.js");
+const os = require("os");
+const args = process.argv.slice(2);
+const tideUrl = args[0] || "http://localhost:9269";
+const deviceName = args[1] || os.hostname();
+const currentRoom = args[2] || "file-room";
+const client = new FileTideClient(deviceName, tideUrl, currentRoom, true, true);

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@trap_stevo/filetide-client",
+  "version": "0.0.0",
+  "description": "Seamless, real-time file transfers between devices with effortless connectivity. Allowing for powerful, instant, secure, and cross-platform file sharing, enabling efficient and reliable data transfers in any network environment.",
+  "main": "dist/cjs/FileTideClient.js",
+  "exports": {
+    ".": "./dist/cjs/FileTideClient.js"
+  },
+  "scripts": {
+    "build": "babel src -d dist/cjs --env-name cjs",
+    "start": "node ./dist/cjs/FileTideClient.js"
+  },
+  "keywords": [
+    "Legendary",
+    "Enlightened",
+    "Steven Compton",
+    "Magical",
+    "real-time",
+    "file-transfer",
+    "file-sharing",
+    "file-sync",
+    "peer-to-peer",
+    "p2p",
+    "networking",
+    "data-transfer",
+    "file-upload",
+    "file-download",
+    "secure-transfer",
+    "live-file-transfer",
+    "cross-platform",
+    "fast-transfer",
+    "file-syncing",
+    "data-streaming",
+    "real-time-sync"
+  ],
+  "author": "Steven Compton",
+  "license": "ISC",
+  "dependencies": {
+    "@trap_stevo/filetide": "^0.0.31",
+    "@trap_stevo/iotide": "^0.0.37",
+    "@trap_stevo/legendarybuilderpronodejs-utilities": "^1.0.36",
+    "chalk": "^4.1.2",
+    "readline": "^1.3.0"
+  },
+  "devDependencies": {
+    "@babel/cli": "^7.24.8",
+    "@babel/core": "^7.25.2",
+    "@babel/plugin-proposal-class-properties": "^7.18.6",
+    "@babel/plugin-transform-runtime": "^7.24.7",
+    "@babel/preset-env": "^7.25.3"
+  }
+}