@trap_stevo/filenet/dist/cjs/index.js

Provides the groundbreaking solution for real-time, OTA (Over-The-Air) file transfer, streamlining client-to-client sharing with unmatched efficiency and effortless, on-the-fly handling. Whether managing peer-to-peer or client-server transfers, FileNet en

"use strict";

function _classPrivateFieldInitSpec(e, t, a) { _checkPrivateRedeclaration(e, t), t.set(e, a); }
function _checkPrivateRedeclaration(e, t) { if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object"); }
function _classPrivateFieldGet(s, a) { return s.get(_assertClassBrand(s, a)); }
function _classPrivateFieldSet(s, a, r) { return s.set(_assertClassBrand(s, a), r), r; }
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 FileTide = require("@trap_stevo/filetide");
var _onFileNetTideAction = /*#__PURE__*/new WeakMap();
var _onFileNetLaunch = /*#__PURE__*/new WeakMap();
var _netConfigurations = /*#__PURE__*/new WeakMap();
var _transportOptions = /*#__PURE__*/new WeakMap();
var _netOptions = /*#__PURE__*/new WeakMap();
class FileNet {
  constructor(debugMode = true) {
    _classPrivateFieldInitSpec(this, _onFileNetTideAction, null);
    _classPrivateFieldInitSpec(this, _onFileNetLaunch, null);
    _classPrivateFieldInitSpec(this, _netConfigurations, []);
    _classPrivateFieldInitSpec(this, _transportOptions, {});
    _classPrivateFieldInitSpec(this, _netOptions, {});
    this.fileNetManager = new FileTide(debugMode);
    return;
  }

  // --- FileNet Gateway Management ---

  launch(fileNetID, netOptions = {}, onLaunch, onTideAction = null, transportOptions = {
    parallelChunks: 3,
    maxRetries: 3
  }, ...netConfigurations) {
    this.fileNetManager.launchFileTide(netOptions, onLaunch, transportOptions, onTideAction, ...netConfigurations);
    this.fileNetManager.currentUserID = fileNetID;
    _classPrivateFieldSet(_onFileNetTideAction, this, onTideAction);
    _classPrivateFieldSet(_onFileNetLaunch, this, onLaunch);
    _classPrivateFieldSet(_netConfigurations, this, netConfigurations);
    _classPrivateFieldSet(_transportOptions, this, transportOptions);
    _classPrivateFieldSet(_netOptions, this, netOptions);
    return;
  }

  // --- FileNet TideToken Enforcement Management ---

  updateTideTokenEnforcementCallbackConfigurations(updatedConfigurations = {}) {
    this.fileNetManager.updateTideTokenEnforcementCallbackConfigurations(updatedConfigurations);
  }
  async registerTideToken(tideToken, meta = {}) {
    return await this.fileNetManager.registerTideToken(tideToken, meta);
  }
  async inspectTideToken(tideToken) {
    return await this.fileNetManager.inspectTideToken(tideToken);
  }
  getTideTokenEnforcerOverviewMetrics() {
    return this.fileNetManager.getTideTokenEnforcerOverviewMetrics();
  }
  getTideToken(scope = "default") {
    return this.fileNetManager.getTideToken(scope);
  }

  // --- FileNet Tidalytics Management ---

  async getTidalyticsSince(interval = "1d", source = "storage", filter = {}) {
    if (!this.operational()) {
      return null;
    }
    return await this.fileNetManager.fileNet.getTidalyticsSince(interval, source, filter);
  }
  async getTidalyticsBetween(start, end, source = "both", filter = {}) {
    if (!this.operational()) {
      return null;
    }
    return await this.fileNetManager.fileNet.getTidalyticsBetween(start, end, source, filter);
  }
  async getStoredTidalytics(filter = {}) {
    if (!this.operational()) {
      return null;
    }
    return await this.fileNetManager.fileNet.getStoredTidalytics(filter);
  }
  async getTidalyticsFromDomains(domains = [], options = {}) {
    if (!this.operational()) {
      return null;
    }
    return await this.fileNetManager.fileNet.getTidalyticsFromDomains(domains, options);
  }
  async getTidalyticsInDomain(domain, options = {}) {
    if (!this.operational()) {
      return null;
    }
    return await this.fileNetManager.fileNet.getTidalyticsInDomain(domain, options);
  }
  getTidalytics(filter = {}) {
    if (!this.operational()) {
      return null;
    }
    return this.fileNetManager.fileNet.getTidalytics(filter);
  }
  getTidalyticByID(id) {
    if (!this.operational()) {
      return null;
    }
    return this.fileNetManager.fileNet.getTidalyticByID(id);
  }
  searchTidalyticByTagValue(key, match) {
    if (!this.operational()) {
      return null;
    }
    return this.fileNetManager.fileNet.searchTidalyticByTagValue(key, match);
  }
  getTidalyticAggregate(name) {
    if (!this.operational()) {
      return null;
    }
    return this.fileNetManager.fileNet.getTidalyticAggregate(name);
  }
  getTidalyticAggregateByType(type) {
    if (!this.operational()) {
      return null;
    }
    return this.fileNetManager.fileNet.getTidalyticAggregateByType(type);
  }
  groupTidalyticByTag(tagKey) {
    if (!this.operational()) {
      return null;
    }
    return this.fileNetManager.fileNet.groupTidalyticByTag(tagKey);
  }
  getTidalyticTimeSeries(name, options = {}) {
    if (!this.operational()) {
      return null;
    }
    return this.fileNetManager.fileNet.getTidalyticTimeSeries(name, options);
  }
  predictTidalytic(name, config = {}) {
    if (!this.operational()) {
      return null;
    }
    return this.fileNetManager.fileNet.predictTidalytic(name, config);
  }
  async clearTidalytics(domain, options = {}) {
    if (!this.operational()) {
      return null;
    }
    return await this.fileNetManager.fileNet.clearTidalytics(domain, options);
  }
  clearAllTidalytics() {
    if (!this.operational()) {
      return null;
    }
    return this.fileNetManager.fileNet.clearAllTidalytics();
  }
  async getTiderPresenceVisualData(options = {}) {
    if (!this.operational()) {
      return null;
    }
    return await this.fileNetManager.fileNet.getTiderPresenceVisualData(options);
  }
  async getAlreadyOnlineVisualData(options = {}) {
    if (!this.operational()) {
      return null;
    }
    return await this.fileNetManager.fileNet.getAlreadyOnlineVisualData(options);
  }
  async getTiderBanVisualData(options = {}) {
    if (!this.operational()) {
      return null;
    }
    return await this.fileNetManager.fileNet.getTiderBanVisualData(options);
  }
  async getTideFileTransferVisualData(options = {}) {
    if (!this.operational()) {
      return null;
    }
    return await this.fileNetManager.fileNet.getTideFileTransferVisualData(options);
  }
  async getTideTransferStateVisualData(options = {}) {
    if (!this.operational()) {
      return null;
    }
    return await this.fileNetManager.fileNet.getTideTransferStateVisualData(options);
  }
  async getFileListActivityVisualData(options = {}) {
    if (!this.operational()) {
      return null;
    }
    return await this.fileNetManager.fileNet.getFileListActivityVisualData(options);
  }
  async getTideBarrierVisualData(options = {}) {
    if (!this.operational()) {
      return null;
    }
    return await this.fileNetManager.fileNet.getTideBarrierVisualData(options);
  }

  // --- FileNet Tidalytics Event Management ---

  attachTiderPresenceVisualStream(options = {}) {
    if (!this.operational()) {
      return null;
    }
    return this.fileNetManager.fileNet.attachTiderPresenceVisualStream(options);
  }
  attachAlreadyOnlineVisualStream(options = {}) {
    if (!this.operational()) {
      return null;
    }
    return this.fileNetManager.fileNet.attachAlreadyOnlineVisualStream(options);
  }
  attachTiderBanVisualStream(options = {}) {
    if (!this.operational()) {
      return null;
    }
    return this.fileNetManager.fileNet.attachTiderBanVisualStream(options);
  }
  attachTideFileTransferVisualStream(options = {}) {
    if (!this.operational()) {
      return null;
    }
    return this.fileNetManager.fileNet.attachTideFileTransferVisualStream(options);
  }
  attachTideTransferStateVisualStream(options = {}) {
    if (!this.operational()) {
      return null;
    }
    return this.fileNetManager.fileNet.attachTideTransferStateVisualStream(options);
  }
  attachFileListVisualStream(options = {}) {
    if (!this.operational()) {
      return null;
    }
    return this.fileNetManager.fileNet.attachFileListVisualStream(options);
  }
  attachTideBarrierVisualStream(options = {}) {
    if (!this.operational()) {
      return null;
    }
    return this.fileNetManager.fileNet.attachTideBarrierVisualStream(options);
  }

  // --- FileNet Tide Actions Management ---

  async getAllTideActions(options = {}) {
    if (!this.operational()) {
      return null;
    }
    return await this.fileNetManager.fileNet.getAllTideActions(options);
  }
  async getTideCompletedTransferActions(options = {}) {
    if (!this.operational()) {
      return null;
    }
    return await this.fileNetManager.fileNet.getTideCompletedTransferActions(options);
  }
  async getTideTransferStateActions(options = {}) {
    if (!this.operational()) {
      return null;
    }
    return await this.fileNetManager.fileNet.getTideTransferStateActions(options);
  }
  async getTideIncomingFileActions(options = {}) {
    if (!this.operational()) {
      return null;
    }
    return await this.fileNetManager.fileNet.getTideIncomingFileActions(options);
  }
  async getTideIncomingTransferActions(options = {}) {
    if (!this.operational()) {
      return null;
    }
    return await this.fileNetManager.fileNet.getTideIncomingTransferActions(options);
  }
  async getTideBarrierAcceptedActions(options = {}) {
    if (!this.operational()) {
      return null;
    }
    return await this.fileNetManager.fileNet.getTideBarrierAcceptedActions(options);
  }
  async getTideBarrierDeniedActions(options = {}) {
    if (!this.operational()) {
      return null;
    }
    return await this.fileNetManager.fileNet.getTideBarrierDeniedActions(options);
  }
  async getFileListReceivedActions(options = {}) {
    if (!this.operational()) {
      return null;
    }
    return await this.fileNetManager.fileNet.getFileListReceivedActions(options);
  }
  async getFileListRequestActions(options = {}) {
    if (!this.operational()) {
      return null;
    }
    return await this.fileNetManager.fileNet.getFileListRequestActions(options);
  }
  async getTiderBannedActions(options = {}) {
    if (!this.operational()) {
      return null;
    }
    return await this.fileNetManager.fileNet.getTiderBannedActions(options);
  }
  async getTiderKickedActions(options = {}) {
    if (!this.operational()) {
      return null;
    }
    return await this.fileNetManager.fileNet.getTiderKickedActions(options);
  }
  async getTiderUnbannedActions(options = {}) {
    if (!this.operational()) {
      return null;
    }
    return await this.fileNetManager.fileNet.getTiderUnbannedActions(options);
  }
  async getTiderAlreadyOnlineActions(options = {}) {
    if (!this.operational()) {
      return null;
    }
    return await this.fileNetManager.fileNet.getTiderAlreadyOnlineActions(options);
  }
  async getTiderOnlineActions(options = {}) {
    if (!this.operational()) {
      return null;
    }
    return await this.fileNetManager.fileNet.getTiderOnlineActions(options);
  }
  async getTiderOfflineActions(options = {}) {
    if (!this.operational()) {
      return null;
    }
    return await this.fileNetManager.fileNet.getTiderOfflineActions(options);
  }

  // --- FileNet Tide Sentinel Management ---

  banClient(clientID, options = {}) {
    if (!this.operational()) {
      return null;
    }
    return this.fileNetManager.fileNet.banClient(clientID, options);
  }
  kickClient(clientID, options = {}) {
    if (!this.operational()) {
      return null;
    }
    return this.fileNetManager.fileNet.kickClient(clientID, options);
  }
  unbanClient(clientID) {
    if (!this.operational()) {
      return null;
    }
    return this.fileNetManager.fileNet.unbanClient(clientID);
  }
  clientBanned(clientID) {
    if (!this.operational()) {
      return null;
    }
    return this.fileNetManager.fileNet.clientBanned(clientID);
  }
  getBanEntry(clientID) {
    if (!this.operational()) {
      return null;
    }
    return this.fileNetManager.fileNet.getBanEntry(clientID);
  }
  filterBannedClients(filter = {}) {
    if (!this.operational()) {
      return null;
    }
    return this.fileNetManager.fileNet.filterBannedClients(filter);
  }
  registerTideSentinelExpireHook(list, callback) {
    if (!this.operational()) {
      return null;
    }
    return this.fileNetManager.fileNet.registerTideSentinelExpireHook(list, callback);
  }
  addToTideList(list, key, data) {
    if (!this.operational()) {
      return null;
    }
    return this.fileNetManager.fileNet.addToTideList(list, key, data);
  }
  removeFromTideList(list, key) {
    if (!this.operational()) {
      return null;
    }
    return this.fileNetManager.fileNet.removeFromTideList(list, key);
  }
  inTideList(list, key) {
    if (!this.operational()) {
      return null;
    }
    return this.fileNetManager.fileNet.inTideList(list, key);
  }
  getEntry(list, key) {
    if (!this.operational()) {
      return null;
    }
    return this.fileNetManager.fileNet.getEntry(list, key);
  }
  filterTideList(list, filter = {}) {
    if (!this.operational()) {
      return null;
    }
    return this.fileNetManager.fileNet.filterTideList(list, filter);
  }
  findSimilarKeys(keyword, options = {}) {
    if (!this.operational()) {
      return null;
    }
    return this.fileNetManager.fileNet.findSimilarKeys(keyword, options);
  }

  // --- FileNet Path Management ---

  async getDirectoryData(directoryPath) {
    return await this.fileNetManager.getDirectoryData(directoryPath);
  }
  getFileData(filePath) {
    return this.fileNetManager.getFileData(filePath);
  }
  async getPathData(inputPath) {
    return await this.fileNetManager.getPathData(inputPath);
  }
  getTidePath(inputPath) {
    return this.fileNetManager.getTidePath(inputPath);
  }

  // --- FileNet Client Management ---

  getClientFromID(clientID) {
    if (!this.operational()) {
      return null;
    }
    return this.fileNetManager.fileNet.getClientFromID(clientID);
  }
  getConnectedClients() {
    if (!this.operational()) {
      return null;
    }
    return this.fileNetManager.fileNet.onlineClients;
  }

  // --- FileNet Transfer Management ---

  async sendToDevice(userID, filePath, destinationPath, filterContent = [], tideSize = 200, tidalSize = 500, minTideSize = 10, maxTideSize = 2000, transferRequestExpirationTime = 30000) {
    await this.fileNetManager.sendToDevice(userID, filePath, destinationPath, filterContent, tideSize, tidalSize, minTideSize, maxTideSize, transferRequestExpirationTime);
    return;
  }

  // --- FileNet Operation Management ---

  operational() {
    return this.fileNetManager.fileTideOperational();
  }
  reboot(fileNetID) {
    this.close();
    setTimeout(() => {
      const currentFileNetID = fileNetID ?? this.fileNetManager.currentUserID;
      this.launch(currentFileNetID, _classPrivateFieldGet(_netOptions, this), _classPrivateFieldGet(_onFileNetLaunch, this), _classPrivateFieldGet(_onFileNetTideAction, this), _classPrivateFieldGet(_transportOptions, this), ..._classPrivateFieldGet(_netConfigurations, this));
    }, 169);
  }
  close() {
    this.fileNetManager.stopFileTide();
    return;
  }
}
;
module.exports = FileNet;