@trap_stevo/filetide 0.0.84 → 0.0.86

package/dist/cjs/HUDManagers/FileTideNetworkTrafficManager.js

@@ -0,0 +1,419 @@
+"use strict";
+
+var EventEmitter = require('events').EventEmitter;
+var EVENTS = Object.freeze({
+  NETWORK_AVAILABLE: 'network:available',
+  NETWORK_CONGESTED: 'network:congested',
+  NETWORK_UNSTABLE: 'network:unstable',
+  TRANSFER_PAUSE: 'transfer:pause',
+  TRANSFER_RESUME: 'transfer:resume',
+  CHUNK_SEND: 'chunk:send',
+  CHUNK_DELAY: 'chunk:delay',
+  CHUNK_RESIZE: 'chunk:resize',
+  BANDWIDTH_UPDATED: 'bandwidth:updated'
+});
+var STATES = Object.freeze({
+  UNKNOWN: 'unknown',
+  AVAILABLE: 'available',
+  CONGESTED: 'congested',
+  UNSTABLE: 'unstable',
+  OFFLINE: 'offline'
+});
+var DEFAULTS = Object.freeze({
+  defaultBandwidthBps: 1024 * 1024,
+  minimumBandwidthBps: 32 * 1024,
+  maximumBandwidthBps: 1024 * 1024 * 1024,
+  targetUtilization: 0.9,
+  congestedUtilizationFactor: 0.65,
+  targetChunkDurationMs: 250,
+  minChunkSize: 16 * 1024,
+  maxChunkSize: 1024 * 1024,
+  burstSeconds: 0.25,
+  congestedLatencyMs: 250,
+  unstableLatencyMs: 1000,
+  congestedFailureRate: 0.1,
+  unstableFailureRate: 0.3,
+  sampleWindowSize: 20,
+  smoothingFactor: 0.25,
+  throughputProbeIntervalMs: 2000,
+  throughputProbeGrowthFactor: 1.10,
+  healthyThroughputRatio: 0.90,
+  degradedThroughputRatio: 0.65
+});
+function clamp(value, minimum, maximum) {
+  return Math.min(Math.max(value, minimum), maximum);
+}
+function assertPositiveNumber(value, name) {
+  if (typeof value !== 'number' || !isFinite(value) || value <= 0) {
+    throw new TypeError(name + " expects a positive number");
+  }
+}
+function mergeOptions(options) {
+  var merged = {};
+  var key;
+  for (key in DEFAULTS) {
+    if (Object.prototype.hasOwnProperty.call(DEFAULTS, key)) {
+      merged[key] = DEFAULTS[key];
+    }
+  }
+  options = options || {};
+  for (key in options) {
+    if (key !== 'clock' && Object.prototype.hasOwnProperty.call(options, key)) {
+      merged[key] = options[key];
+    }
+  }
+  return merged;
+}
+function FileTideNetworkTrafficManager(options) {
+  EventEmitter.call(this);
+  options = options || {};
+  this._config = mergeOptions(options);
+  this._clock = typeof options.clock === 'function' ? options.clock : Date.now;
+  this._state = STATES.UNKNOWN;
+  this._paused = false;
+  this._manualPause = false;
+  this._autoPaused = false;
+  this._pauseReason = null;
+  this._bandwidthBps = null;
+  this._deliveredThroughputBps = null;
+  this._latencyMs = null;
+  this._samples = [];
+  this._lastThroughputProbeAt = 0;
+  this._tokens = this._getBucketCapacity();
+  this._lastRefillAt = this._clock();
+  this._validateConfiguration();
+}
+FileTideNetworkTrafficManager.prototype = Object.create(EventEmitter.prototype);
+FileTideNetworkTrafficManager.prototype.constructor = FileTideNetworkTrafficManager;
+FileTideNetworkTrafficManager.prototype._validateConfiguration = function () {
+  assertPositiveNumber(this._config.defaultBandwidthBps, "defaultBandwidthBps");
+  assertPositiveNumber(this._config.minimumBandwidthBps, "minimumBandwidthBps");
+  assertPositiveNumber(this._config.targetChunkDurationMs, "targetChunkDurationMs");
+  assertPositiveNumber(this._config.minChunkSize, 'minChunkSize');
+  assertPositiveNumber(this._config.maxChunkSize, 'maxChunkSize');
+  assertPositiveNumber(this._config.burstSeconds, 'burstSeconds');
+  assertPositiveNumber(this._config.sampleWindowSize, 'sampleWindowSize');
+  if (this._config.targetUtilization <= 0 || this._config.targetUtilization > 1) {
+    throw new RangeError("targetUtilization expects greater than 0 and at most 1");
+  }
+  if (this._config.congestedUtilizationFactor <= 0 || this._config.congestedUtilizationFactor > 1) {
+    throw new RangeError("congestedUtilizationFactor expects greater than 0 and at most 1");
+  }
+  if (this._config.smoothingFactor <= 0 || this._config.smoothingFactor > 1) {
+    throw new RangeError("smoothingFactor expects greater than 0 and at most 1");
+  }
+  if (this._config.minChunkSize > this._config.maxChunkSize) {
+    throw new RangeError("minChunkSize cannot exceed maxChunkSize");
+  }
+  assertPositiveNumber(this._config.maximumBandwidthBps, "maximumBandwidthBps");
+  assertPositiveNumber(this._config.throughputProbeIntervalMs, "throughputProbeIntervalMs");
+  if (this._config.throughputProbeGrowthFactor <= 1) {
+    throw new RangeError("throughputProbeGrowthFactor expects greater than 1");
+  }
+  if (this._config.healthyThroughputRatio <= 0 || this._config.healthyThroughputRatio > 1) {
+    throw new RangeError("healthyThroughputRatio expects greater than 0 and at most 1");
+  }
+  if (this._config.degradedThroughputRatio <= 0 || this._config.degradedThroughputRatio >= this._config.healthyThroughputRatio) {
+    throw new RangeError("degradedThroughputRatio expects greater than 0 and less than healthyThroughputRatio");
+  }
+};
+FileTideNetworkTrafficManager.prototype._smooth = function (current, sample) {
+  if (current === null) {
+    return sample;
+  }
+  return this._config.smoothingFactor * sample + (1 - this._config.smoothingFactor) * current;
+};
+FileTideNetworkTrafficManager.prototype._getFailureRate = function () {
+  if (this._samples.length === 0) {
+    return 0;
+  }
+  var failures = this._samples.reduce(function (total, sample) {
+    return total + (sample.success ? 0 : 1);
+  }, 0);
+  return failures / this._samples.length;
+};
+FileTideNetworkTrafficManager.prototype._getRetryRate = function () {
+  if (this._samples.length === 0) {
+    return 0;
+  }
+  var retries = this._samples.reduce(function (total, sample) {
+    return total + (sample.retried ? 1 : 0);
+  }, 0);
+  return retries / this._samples.length;
+};
+FileTideNetworkTrafficManager.prototype._evaluateState = function (online) {
+  var failureRate = this._getFailureRate();
+  var retryRate = this._getRetryRate();
+  if (online === false) {
+    return STATES.OFFLINE;
+  }
+  if (this._latencyMs !== null && this._latencyMs >= this._config.unstableLatencyMs) {
+    return STATES.UNSTABLE;
+  }
+  if (failureRate >= this._config.unstableFailureRate) {
+    return STATES.UNSTABLE;
+  }
+  if (this._latencyMs !== null && this._latencyMs >= this._config.congestedLatencyMs) {
+    return STATES.CONGESTED;
+  }
+  if (failureRate >= this._config.congestedFailureRate || retryRate >= this._config.congestedFailureRate) {
+    return STATES.CONGESTED;
+  }
+  return STATES.AVAILABLE;
+};
+FileTideNetworkTrafficManager.prototype._setState = function (nextState) {
+  if (nextState === this._state) {
+    return;
+  }
+  var previousState = this._state;
+  this._state = nextState;
+  var eventPayload = {
+    state: nextState,
+    previousState: previousState,
+    status: this.getStatus()
+  };
+  if (nextState === STATES.AVAILABLE) {
+    this.emit(EVENTS.NETWORK_AVAILABLE, eventPayload);
+    if (this._autoPaused && !this._manualPause) {
+      this.resume('network-recovered', true);
+    }
+    return;
+  }
+  if (nextState === STATES.CONGESTED) {
+    this.emit(EVENTS.NETWORK_CONGESTED, eventPayload);
+    return;
+  }
+  this.emit(EVENTS.NETWORK_UNSTABLE, eventPayload);
+  this.pause(nextState === STATES.OFFLINE ? 'network-offline' : 'network-unstable', true);
+};
+FileTideNetworkTrafficManager.prototype.updateNetworkSample = function (sample) {
+  sample = sample || {};
+  if (sample.bandwidthBps !== undefined) {
+    assertPositiveNumber(sample.bandwidthBps, 'bandwidthBps');
+    this._refillTokens();
+    var previousCapacity = this._getBucketCapacity();
+    var fillRatio = clamp(this._tokens / previousCapacity, 0, 1);
+    this._bandwidthBps = this._smooth(this._bandwidthBps, sample.bandwidthBps);
+    this._tokens = fillRatio * this._getBucketCapacity();
+    this.emit(EVENTS.BANDWIDTH_UPDATED, {
+      bandwidthBps: this._bandwidthBps,
+      status: this.getStatus()
+    });
+  }
+  if (sample.latencyMs !== undefined) {
+    if (typeof sample.latencyMs !== 'number' || !isFinite(sample.latencyMs) || sample.latencyMs < 0) {
+      throw new TypeError("latencyMs expects a non-negative number");
+    }
+    this._latencyMs = this._smooth(this._latencyMs, sample.latencyMs);
+  }
+  if (sample.success !== undefined || sample.retried !== undefined) {
+    this._samples.push({
+      success: sample.success !== false,
+      retried: sample.retried === true,
+      timestamp: this._clock()
+    });
+    if (this._samples.length > this._config.sampleWindowSize) {
+      this._samples.shift();
+    }
+  }
+  this._setState(this._evaluateState(sample.online));
+  return this.getStatus();
+};
+FileTideNetworkTrafficManager.prototype.recordTransfer = function (result) {
+  result = result || {};
+  assertPositiveNumber(result.bytes, 'bytes');
+  assertPositiveNumber(result.durationMs, 'durationMs');
+  return this.updateNetworkSample({
+    bandwidthBps: result.bytes / (result.durationMs / 1000),
+    latencyMs: result.latencyMs,
+    online: result.online,
+    success: result.success,
+    retried: result.retried
+  });
+};
+FileTideNetworkTrafficManager.prototype.recordDeliveredThroughput = function (throughputBps) {
+  assertPositiveNumber(throughputBps, "throughputBps");
+  var now = this._clock();
+  this._deliveredThroughputBps = this._smooth(this._deliveredThroughputBps, throughputBps);
+  this._setState(this._evaluateState(true));
+  var currentBandwidth = this._bandwidthBps || this._config.defaultBandwidthBps;
+  var currentSendRate = this._getSendRate();
+  var throughputRatio = currentSendRate > 0 ? this._deliveredThroughputBps / currentSendRate : 0;
+  if (now - this._lastThroughputProbeAt < this._config.throughputProbeIntervalMs) {
+    return this.getStatus();
+  }
+  this._lastThroughputProbeAt = now;
+  var nextBandwidth = currentBandwidth;
+  if (this._state === STATES.AVAILABLE && throughputRatio >= this._config.healthyThroughputRatio) {
+    nextBandwidth = Math.min(currentBandwidth * this._config.throughputProbeGrowthFactor, this._config.maximumBandwidthBps);
+  } else if (throughputRatio < this._config.degradedThroughputRatio) {
+    var observedCapacity = this._deliveredThroughputBps / this._config.targetUtilization;
+    nextBandwidth = this._smooth(currentBandwidth, observedCapacity);
+    nextBandwidth = Math.max(nextBandwidth, this._config.minimumBandwidthBps);
+  }
+  nextBandwidth = Math.min(nextBandwidth, this._config.maximumBandwidthBps);
+  if (nextBandwidth !== currentBandwidth) {
+    this._refillTokens();
+    var previousCapacity = this._getBucketCapacity();
+    var fillRatio = clamp(this._tokens / previousCapacity, 0, 1);
+    this._bandwidthBps = nextBandwidth;
+    this._tokens = fillRatio * this._getBucketCapacity();
+    this.emit(EVENTS.BANDWIDTH_UPDATED, {
+      bandwidthBps: this._bandwidthBps,
+      deliveredThroughputBps: this._deliveredThroughputBps,
+      throughputRatio,
+      status: this.getStatus()
+    });
+  }
+  return this.getStatus();
+};
+FileTideNetworkTrafficManager.prototype.waitForChunkAdmission = function (requestedBytes) {
+  var self = this;
+  assertPositiveNumber(requestedBytes, "requestedBytes");
+  return new Promise(function (resolve) {
+    function evaluate() {
+      var decision = self.getChunkDecision(requestedBytes);
+      if (decision.action === "send") {
+        resolve(decision);
+        return;
+      }
+      if (decision.action === "pause") {
+        self.once(EVENTS.TRANSFER_RESUME, evaluate);
+        return;
+      }
+      setTimeout(evaluate, Math.max(decision.delayMs || 1, 1));
+    }
+    evaluate();
+  });
+};
+FileTideNetworkTrafficManager.prototype.pause = function (reason, automatic) {
+  if (automatic !== true) {
+    this._manualPause = true;
+  } else {
+    this._autoPaused = true;
+  }
+  this._pauseReason = reason || 'requested';
+  if (this._paused) {
+    return this.getStatus();
+  }
+  this._paused = true;
+  this.emit(EVENTS.TRANSFER_PAUSE, {
+    reason: this._pauseReason,
+    automatic: automatic === true,
+    status: this.getStatus()
+  });
+  return this.getStatus();
+};
+FileTideNetworkTrafficManager.prototype.resume = function (reason, automatic) {
+  if (automatic === true && this._manualPause) {
+    return this.getStatus();
+  }
+  if (automatic !== true) {
+    this._manualPause = false;
+  }
+  this._autoPaused = false;
+  this._pauseReason = null;
+  if (!this._paused) {
+    return this.getStatus();
+  }
+  this._paused = false;
+  this._lastRefillAt = this._clock();
+  this.emit(EVENTS.TRANSFER_RESUME, {
+    reason: reason || 'requested',
+    automatic: automatic === true,
+    status: this.getStatus()
+  });
+  return this.getStatus();
+};
+FileTideNetworkTrafficManager.prototype._getSendRate = function () {
+  var bandwidth = this._bandwidthBps || this._config.defaultBandwidthBps;
+  var rate = Math.max(bandwidth * this._config.targetUtilization, this._config.minimumBandwidthBps);
+  if (this._state === STATES.CONGESTED) {
+    rate *= this._config.congestedUtilizationFactor;
+  }
+  return rate;
+};
+FileTideNetworkTrafficManager.prototype._getBucketCapacity = function () {
+  var bandwidth = this._bandwidthBps || this._config.defaultBandwidthBps;
+  return Math.max(bandwidth * this._config.burstSeconds, this._config.maxChunkSize);
+};
+FileTideNetworkTrafficManager.prototype._refillTokens = function () {
+  var now = this._clock();
+  var elapsedMs = Math.max(now - this._lastRefillAt, 0);
+  var addedTokens = this._getSendRate() * (elapsedMs / 1000);
+  this._tokens = Math.min(this._tokens + addedTokens, this._getBucketCapacity());
+  this._lastRefillAt = now;
+};
+FileTideNetworkTrafficManager.prototype.getRecommendedChunkSize = function () {
+  var targetSize = this._getSendRate() * (this._config.targetChunkDurationMs / 1000);
+  return Math.round(clamp(targetSize, this._config.minChunkSize, this._config.maxChunkSize));
+};
+FileTideNetworkTrafficManager.prototype.getChunkDecision = function (requestedBytes) {
+  assertPositiveNumber(requestedBytes, 'requestedBytes');
+  if (this._paused) {
+    return {
+      action: 'pause',
+      allowed: false,
+      reason: this._pauseReason,
+      delayMs: null,
+      chunkSize: 0
+    };
+  }
+  this._refillTokens();
+  var recommendedSize = this.getRecommendedChunkSize();
+  var chunkSize = Math.min(requestedBytes, recommendedSize);
+  if (chunkSize !== requestedBytes) {
+    this.emit(EVENTS.CHUNK_RESIZE, {
+      requestedBytes: requestedBytes,
+      chunkSize: chunkSize,
+      status: this.getStatus()
+    });
+  }
+  if (this._tokens >= chunkSize) {
+    this._tokens -= chunkSize;
+    var sendDecision = {
+      action: 'send',
+      allowed: true,
+      reason: 'capacity-available',
+      delayMs: 0,
+      chunkSize: chunkSize
+    };
+    this.emit(EVENTS.CHUNK_SEND, sendDecision);
+    return sendDecision;
+  }
+  var delayMs = Math.ceil((chunkSize - this._tokens) / this._getSendRate() * 1000);
+  var delayDecision = {
+    action: 'delay',
+    allowed: false,
+    reason: 'bandwidth-throttled',
+    delayMs: Math.max(delayMs, 1),
+    chunkSize: chunkSize
+  };
+  this.emit(EVENTS.CHUNK_DELAY, delayDecision);
+  return delayDecision;
+};
+FileTideNetworkTrafficManager.prototype.canSendChunk = function (requestedBytes) {
+  return this.getChunkDecision(requestedBytes).allowed;
+};
+FileTideNetworkTrafficManager.prototype.getStatus = function () {
+  var sendRateBps = this._getSendRate();
+  return {
+    state: this._state,
+    paused: this._paused,
+    pauseReason: this._pauseReason,
+    bandwidthBps: this._bandwidthBps,
+    deliveredThroughputBps: this._deliveredThroughputBps,
+    latencyMs: this._latencyMs,
+    failureRate: this._getFailureRate(),
+    retryRate: this._getRetryRate(),
+    recommendedChunkSize: this.getRecommendedChunkSize(),
+    sendRateBps,
+    throughputRatio: this._deliveredThroughputBps !== null && sendRateBps > 0 ? this._deliveredThroughputBps / sendRateBps : null,
+    sampleCount: this._samples.length
+  };
+};
+var singleton = new FileTideNetworkTrafficManager();
+module.exports = singleton;
+module.exports.FileTideNetworkTrafficManager = FileTideNetworkTrafficManager;
+module.exports.EVENTS = EVENTS;
+module.exports.STATES = STATES;

package/dist/cjs/HUDManagers/FileTideUniversalPathsUtilityManager.js

@@ -0,0 +1,14 @@
+"use strict";
+
+const path = require("path");
+function getUniversalPrefix() {
+  if (process.platform === "win32") {
+    const winAppDataRoot = process.env.PROGRAMDATA || process.env.APPDATA || path.join(process.env.SYSTEMDRIVE || "C:", "ProgramData");
+    return path.join(winAppDataRoot);
+  }
+  return path.join("/var", "lib");
+}
+;
+module.exports = {
+  getUniversalPrefix
+};