warframe-worldstate-parser 2.32.0 → 3.0.1

package/lib/models/Fissure.js

@@ -1,93 +1,87 @@
-'use strict';
-
-const WorldstateObject = require('./WorldstateObject');
+import {
+  node,
+  nodeMissionType,
+  missionType,
+  nodeEnemy,
+  fissureModifier,
+  fissureTier,
+} from '../utilities/translation.js';
+import { parseDate, fromNow, timeDeltaToString } from '../utilities/timeDate.js';
+
+import WorldstateObject from './WorldstateObject.js';
 
 /**
  * Represents a fissure mission
- * @extends {WorldstateObject}
+ * @augments {WorldstateObject}
  */
-class Fissure extends WorldstateObject {
+export default class Fissure extends WorldstateObject {
   /**
-   * @param   {Object}             data            The fissure data
-   * @param   {Object}             deps            The dependencies object
-   * @param   {Translator}         deps.translator The string translator
-   * @param   {TimeDateFunctions}  deps.timeDate   The time and date functions
+   * @param   {object}             data            The fissure data
+   * @param   {Dependency}             deps            The dependencies object
    * @param   {string}             deps.locale     Locale to use for translations
    */
-  constructor(data, { translator, timeDate, locale }) {
-    super(data, { timeDate });
-
-    /**
-     * The time and date functions
-     * @type {TimeDateFunctions}
-     * @private
-     */
-    this.timeDate = timeDate;
-    Object.defineProperty(this, 'timeDate', { enumerable: false, configurable: false });
+  constructor(data, { locale = 'en' } = { locale: 'en' }) {
+    super(data);
 
     /**
      * The node where the fissure has appeared
      * @type {string}
      */
-    this.node = translator.node(data.Node, locale);
+    this.node = node(data.Node, locale);
 
     /**
      * The fissure mission type
      * @type {string}
      */
-    this.missionType = data.MissionType
-      ? translator.missionType(data.MissionType, locale)
-      : translator.nodeMissionType(data.Node, locale);
+    this.missionType = data.MissionType ? missionType(data.MissionType, locale) : nodeMissionType(data.Node, locale);
 
     /**
      * The fissure mission type key
      * @type {string}
      */
-    this.missionKey = data.MissionType
-      ? translator.missionType(data.MissionType)
-      : translator.nodeMissionType(data.Node);
+    this.missionKey = data.MissionType ? missionType(data.MissionType) : nodeMissionType(data.Node);
 
     /**
      * The faction controlling the node where the fissure has appeared
      * @type {string}
      */
-    this.enemy = translator.nodeEnemy(data.Node, locale);
+    this.enemy = nodeEnemy(data.Node, locale);
 
     /**
      * Faction enum for the faction controlling the node where the fissure has appeared
      * @type {string}
      */
-    this.enemyKey = translator.nodeEnemy(data.Node);
+    this.enemyKey = nodeEnemy(data.Node);
 
     /**
      * The node key where the fissure has appeared
      * @type {string}
      */
-    this.nodeKey = translator.node(data.Node);
+    this.nodeKey = node(data.Node);
 
     /**
      * The fissure's tier
      * @type {string}
      */
-    this.tier = translator.fissureModifier(data.Modifier || data.ActiveMissionTier, locale);
+    this.tier = fissureModifier(data.Modifier || data.ActiveMissionTier, locale);
 
     /**
      * The fissure's tier as a number
      * @type {number}
      */
-    this.tierNum = translator.fissureTier(data.Modifier || data.ActiveMissionTier, locale);
+    this.tierNum = fissureTier(data.Modifier || data.ActiveMissionTier, locale);
 
     /**
      * The date and time at which the fissure appeared
      * @type {Date}
      */
-    this.activation = timeDate.parseDate(data.Activation);
+    this.activation = parseDate(data.Activation);
 
     /**
      * The date and time at which the fissure will disappear
      * @type {Date}
      */
-    this.expiry = timeDate.parseDate(data.Expiry);
+    this.expiry = parseDate(data.Expiry);
 
     /**
      * Whether this is expired (at time of object creation)
@@ -97,46 +91,44 @@ class Fissure extends WorldstateObject {
 
     /**
      * ETA string (at time of object creation)
-     * @type {String}
+     * @type {string}
      */
     this.eta = this.getETAString();
 
     /**
      * Whether this fissure corresponds to a RailJack Void Storm
-     * @type {Boolean}
+     * @type {boolean}
      */
-    this.isStorm = !!data.ActiveMissionTier;
+    this.isStorm = Boolean(data.ActiveMissionTier);
 
     /**
      * Whether this fissure is a Steel Path fissure
      * @type {boolean}
      */
-    this.isHard = !!data.Hard;
+    this.isHard = Boolean(data.Hard);
   }
 
   /**
    * Get whether this deal has expired
-   * @returns {boolean}
+   * @returns {boolean} Whether or not the deal has expired
    */
   getExpired() {
-    return this.timeDate.fromNow(this.expiry) < 0;
+    return fromNow(this.expiry) < 0;
   }
 
   /**
    * Get a string representation of how long the void fissure will remain active
-   * @returns {string}
+   * @returns {string} The string representation of the fissure's remaining time
    */
   getETAString() {
-    return this.timeDate.timeDeltaToString(this.timeDate.fromNow(this.expiry));
+    return timeDeltaToString(fromNow(this.expiry));
   }
 
   /**
    * Returns a string representation of the fissure
-   * @returns {string}
+   * @returns {string}  The string representation of the fissure
    */
   toString() {
     return `[${this.getETAString()}] ${this.tier} fissure at ${this.node} - ${this.enemy} ${this.missionType}`;
   }
 }
-
-module.exports = Fissure;

package/lib/models/FlashSale.js

@@ -1,51 +1,34 @@
-'use strict';
+import mdConfig from '../supporting/MarkdownSettings.js';
+import { languageString } from '../utilities/translation.js';
+import { parseDate, fromNow, timeDeltaToString } from '../utilities/timeDate.js';
 
 /**
  * Represents a flash sale
  */
-class FlashSale {
+export default class FlashSale {
   /**
-   * @param   {Object}             data            The flash sale data
-   * @param   {Object}             deps            The dependencies object
-   * @param   {MarkdownSettings}   deps.mdConfig   The markdown settings
-   * @param   {Translator}         deps.translator The string translator
-   * @param   {TimeDateFunctions}  deps.timeDate   The time and date functions
+   * @param   {object}             data            The flash sale data
+   * @param   {Dependency}             deps            The dependencies object
    * @param   {string}             deps.locale     Locale to use for translations
    */
-  constructor(data, { translator, mdConfig, timeDate, locale }) {
-    /**
-     * The markdown settings
-     * @type {MarkdownSettings}
-     * @private
-     */
-    this.mdConfig = mdConfig;
-    Object.defineProperty(this, 'mdConfig', { enumerable: false, configurable: false });
-
-    /**
-     * The time and date functions
-     * @type {TimeDateFunctions}
-     * @private
-     */
-    this.timeDate = timeDate;
-    Object.defineProperty(this, 'timeDate', { enumerable: false, configurable: false });
-
+  constructor(data, { locale = 'en' } = { locale: 'en' }) {
     /**
      * The item being offered in the flash sale
      * @type {string}
      */
-    this.item = translator.languageString(data.TypeName, locale);
+    this.item = languageString(data.TypeName, locale);
 
     /**
      * The date and time at which the sale will end
      * @type {Date}
      */
-    this.expiry = timeDate.parseDate(data.EndDate);
+    this.expiry = parseDate(data.EndDate);
 
     /**
      * The date and time at which the sale will or did start
      * @type {Date}
      */
-    this.activation = timeDate.parseDate(data.StartDate);
+    this.activation = parseDate(data.StartDate);
 
     /**
      * The item's discount percentage
@@ -97,31 +80,30 @@ class FlashSale {
 
     /**
      * ETA string (at time of object creation)
-     * @type {String}
+     * @type {string}
      */
     this.eta = this.getETAString();
   }
 
   /**
    * Get how much time is left before the deal expires
-   * @returns {string}
+   * @returns {string} The time left before the deal expires
    */
   getETAString() {
-    const timeDelta = this.timeDate.fromNow(this.expiry);
-    return this.timeDate.timeDeltaToString(timeDelta);
+    return timeDeltaToString(fromNow(this.expiry));
   }
 
   /**
    * Get whether or not this deal has expired
-   * @returns {boolean}
+   * @returns {boolean} Whether or not the deal has expired
    */
   getExpired() {
-    return this.timeDate.fromNow(this.expiry) < 0;
+    return fromNow(this.expiry) < 0;
   }
 
   /**
    * Returns a string representation of the flash sale
-   * @returns {string}
+   * @returns {string} The string representation of the flash sale
    */
   toString() {
     const lines = [`${this.item}, ${this.premiumOverride}p`, `Expires in ${this.getETAString()}`];
@@ -136,8 +118,6 @@ class FlashSale {
       lines.unshift('**Featured**');
     }
 
-    return `${this.mdConfig.codeMulti}${lines.join(this.mdConfig.lineEnd)}${this.mdConfig.blockEnd}`;
+    return `${mdConfig.codeBlock}${lines.join(mdConfig.lineEnd)}${mdConfig.blockEnd}`;
   }
 }
-
-module.exports = FlashSale;

package/lib/models/GlobalUpgrade.js

@@ -1,63 +1,48 @@
-'use strict';
-
+import mdConfig from '../supporting/MarkdownSettings.js';
+import { parseDate, fromNow, timeDeltaToString } from '../utilities/timeDate.js';
+import { upgrade, operation, operationSymbol } from '../utilities/translation.js';
 /**
  * Represents an upgrade that applies to all players
  */
-class GlobalUpgrade {
+export default class GlobalUpgrade {
   /**
-   * @param   {Object}             data            The global upgrade data
-   * @param   {Object}             deps            The dependencies object
-   * @param   {Translator}         deps.translator The string translator
-   * @param   {TimeDateFunctions}  deps.timeDate   The time and date functions
-   * @param   {MarkdownSettings}   deps.mdConfig   The markdown settings
+   * @param   {object}             data            The global upgrade data
+   * @param   {object}             deps            The dependencies object
    * @param   {string}             deps.locale     Locale to use for translations
    */
-  constructor(data, { translator, timeDate, mdConfig, locale }) {
-    /**
-     * The time and date functions
-     * @type {TimeDateFunctions}
-     * @private
-     */
-    this.timeDate = timeDate;
-    Object.defineProperty(this, 'timeDate', { enumerable: false, configurable: false });
-
-    /**
-     * The markdown settings
-     * @type {MarkdownSettings}
-     * @private
-     */
-    this.mdConfig = mdConfig;
-    Object.defineProperty(this, 'mdConfig', { enumerable: false, configurable: false });
-
+  constructor(data, { locale = 'en' } = { locale: 'en' }) {
+    if (!data.Activation || !data.ExpiryDate) {
+      throw new TypeError('The provided data does not have the required properties.');
+    }
     /**
      * The time and date at which the global upgrade starts being active
      * @type {Date}
      */
-    this.start = timeDate.parseDate(data.Activation);
+    this.start = parseDate(data.Activation);
 
     /**
      * The time and date at which the global upgrade stops being active
      * @type {Date}
      */
-    this.end = timeDate.parseDate(data.ExpiryDate);
+    this.end = parseDate(data.ExpiryDate);
 
     /**
      * The effect of the upgrade
      * @type {string}
      */
-    this.upgrade = translator.upgrade(data.UpgradeType, locale);
+    this.upgrade = upgrade(data.UpgradeType, locale);
 
     /**
      * The operation type
      * @type {string}
      */
-    this.operation = translator.operation(data.OperationType, locale);
+    this.operation = operation(data.OperationType, locale);
 
     /**
      * Symbol for operation
      * @type {string}
      */
-    this.operationSymbol = translator.operationSymbol(data.OperationType, locale);
+    this.operationSymbol = operationSymbol(data.OperationType, locale);
 
     /**
      * The operation value
@@ -73,7 +58,7 @@ class GlobalUpgrade {
 
     /**
      * ETA string (at time of object creation)
-     * @type {String}
+     * @type {string}
      */
     this.eta = this.getETAString();
 
@@ -86,19 +71,18 @@ class GlobalUpgrade {
 
   /**
    * Get whether or not the event has expired
-   * @returns {boolean}
+   * @returns {boolean} whether the event has expired
    */
   getExpired() {
-    return this.timeDate.fromNow(this.end) < 0;
+    return fromNow(this.end) < 0;
   }
 
   /**
    * Get a string indicating how long it will take for the upgrade to expire
-   * @returns {string}
+   * @returns {string} estimated timer of the upgrade
    */
   getETAString() {
-    const timeDelta = this.timeDate.fromNow(this.end);
-    return this.timeDate.timeDeltaToString(timeDelta);
+    return timeDeltaToString(fromNow(this.end));
   }
 
   /**
@@ -111,14 +95,12 @@ class GlobalUpgrade {
 
   /**
    * Returns a string representation of the upgrade
-   * @returns {string}
+   * @returns {string} string representation
    */
   toString() {
     return (
-      `${this.mdConfig.codeMulti}[${this.getETAString()}] ${this.upgrade}` +
-      `${this.operation} ${this.upgradeOperationValue}${this.mdConfig.blockEnd}`
+      `${mdConfig.codeBlock}[${this.getETAString()}] ${this.upgrade}` +
+      `${this.operation} ${this.upgradeOperationValue}${mdConfig.blockEnd}`
     );
   }
 }
-
-module.exports = GlobalUpgrade;

package/lib/models/Invasion.js

@@ -1,10 +1,12 @@
-'use strict';
-
-const WorldstateObject = require('./WorldstateObject');
+import { node, languageString, faction } from '../utilities/translation.js';
+import { parseDate, timeDeltaToString, toNow } from '../utilities/timeDate.js';
+import mdConfig from '../supporting/MarkdownSettings.js';
 
+import Reward from './Reward.js';
+import WorldstateObject from './WorldstateObject.js';
 /**
  * An invasion participant
- * @typedef {Object} Invasion~Participant
+ * @typedef {object} InvasionParticipant
  * @property {string} reward Reward for supporting this participant in the invasion
  * @property {string} faction Faction of this participant (localized)
  * @property {string} factionKey Faction of this participant (always English)
@@ -13,103 +15,61 @@ const WorldstateObject = require('./WorldstateObject');
 /**
  * Represents an invasion
  */
-class Invasion extends WorldstateObject {
+export default class Invasion extends WorldstateObject {
   /**
-   * @param   {Object}             data            The invasion data
-   * @param   {Object}             deps            The dependencies object
-   * @param   {MarkdownSettings}   deps.mdConfig   The markdown settings
-   * @param   {Translator}         deps.translator The string translator
-   * @param   {TimeDateFunctions}  deps.timeDate   The time and date functions
-   * @param   {Reward}             deps.Reward     The Reward parser
+   * @param   {object}             data            The invasion data
+   * @param   {Dependency}         deps            The dependencies object
    * @param   {string}             deps.locale     Locale to use for translations
    */
-  constructor(data, { mdConfig, translator, timeDate, Reward, locale }) {
-    super(data, { timeDate });
+  constructor(data, { locale = 'en' } = { locale: 'en' }) {
+    super(data);
 
     const opts = {
-      mdConfig,
-      translator,
-      timeDate,
-      Reward,
       locale,
     };
 
-    /**
-     * The markdown settings
-     * @type {MarkdownSettings}
-     * @private
-     */
-    this.mdConfig = mdConfig;
-    Object.defineProperty(this, 'mdConfig', { enumerable: false, configurable: false });
-
-    /**
-     * The time and date functions
-     * @type {TimeDateFunctions}
-     * @private
-     */
-    this.timeDate = timeDate;
-    Object.defineProperty(this, 'timeDate', { enumerable: false, configurable: false });
-
     /**
      * The node where the invasion is taking place
      * @type {string}
      */
-    this.node = translator.node(data.Node, locale);
+    this.node = node(data.Node, locale);
 
     /**
      * The node key where the invasion is taking place
      * @type {string}
      */
-    this.nodeKey = translator.node(data.Node);
+    this.nodeKey = node(data.Node);
 
     /**
      * The invasion's description
      * @type {string}
      */
-    this.desc = translator.languageString(data.LocTag, locale);
-
-    /**
-     * The attacker's reward
-     * @type {Reward}
-     */
-    this.attackerReward = new Reward(data.AttackerReward, opts);
+    this.desc = languageString(data.LocTag, locale);
 
     /**
      * The attacking faction
      * @type {string}
      */
-    this.attackingFaction = translator.faction(data.DefenderMissionInfo.faction, locale);
+    this.attackingFaction = faction(data.DefenderMissionInfo.faction, locale);
 
     /**
      * Invasion attacker
-     * @type {Invasion~Partipant}
+     * @type {InvasionParticipant}
      */
     this.attacker = {
-      reward: this.attackerReward,
-      faction: this.attackingFaction,
-      factionKey: translator.faction(data.DefenderMissionInfo.faction, 'en'),
+      reward: Object.keys(data?.AttackerReward || {})?.length ? new Reward(data.AttackerReward, opts) : undefined,
+      faction: faction(data.DefenderMissionInfo.faction, locale),
+      factionKey: faction(data.DefenderMissionInfo.faction, 'en'),
     };
 
-    /**
-     * The defender's reward
-     * @type {Reward}
-     */
-    this.defenderReward = new Reward(data.DefenderReward, opts);
-
-    /**
-     * The defending faction
-     * @type {string}
-     */
-    this.defendingFaction = translator.faction(data.AttackerMissionInfo.faction, locale);
-
     /**
      * Invasion defender
-     * @type {Partipant}
+     * @type {InvasionParticipant}
      */
     this.defender = {
-      reward: this.defenderReward,
-      faction: this.defendingFaction,
-      factionKey: translator.faction(data.AttackerMissionInfo.faction, 'en'),
+      reward: Object.keys(data?.DefenderReward || {})?.length ? new Reward(data.DefenderReward, opts) : undefined,
+      faction: faction(data.AttackerMissionInfo.faction, locale),
+      factionKey: faction(data.AttackerMissionInfo.faction, 'en'),
     };
 
     /**
@@ -122,7 +82,7 @@ class Invasion extends WorldstateObject {
      * The time at which the invasion starts
      * @type {Date}
      */
-    this.activation = timeDate.parseDate(data.Activation);
+    this.activation = parseDate(data.Activation);
 
     /**
      * The signed count of completed runs. Supporting the attackers makes the count go up,
@@ -152,7 +112,7 @@ class Invasion extends WorldstateObject {
 
     /**
      * ETA string (at time of object creation)
-     * @type {String}
+     * @type {string}
      */
     this.eta = this.getETAString();
 
@@ -166,7 +126,7 @@ class Invasion extends WorldstateObject {
   /**
    * Whether or not the attackers are winning.
    * This is always false when the infestation is attacking
-   * @returns {boolean}
+   * @returns {boolean} whether the attacker is winning
    */
   isAttackerWinning() {
     return this.count > 0;
@@ -174,52 +134,50 @@ class Invasion extends WorldstateObject {
 
   /**
    * Get an estimation of how much time is left before the invasion ends in milliseconds
-   * @returns {number}
+   * @returns {number} remaining time in ms
    */
   getRemainingTime() {
     const completedRuns = Math.abs(this.count);
-    const elapsedMillis = this.timeDate.toNow(this.activation);
+    const elapsedMillis = toNow(this.activation);
     const remainingRuns = this.requiredRuns - completedRuns;
     return remainingRuns * (elapsedMillis / completedRuns);
   }
 
   /**
    * Get a string estimating how much time is left before the invasion ends
-   * @returns {string}
+   * @returns {string} time delta string from now to the end
    */
   getETAString() {
-    return this.timeDate.timeDeltaToString(this.getRemainingTime());
+    return timeDeltaToString(this.getRemainingTime());
   }
 
   /**
    * Get the types of the items being rewarded in the invasion
-   * @returns {Array.<string>}
+   * @returns {Array<string>} types of items being rewarded
    */
   getRewardTypes() {
-    return this.attacker.reward.getTypes().concat(this.defender.reward.getTypes());
+    return [...(this.attacker.reward?.getTypes() ?? []), ...(this.defender.reward?.getTypes() ?? [])];
   }
 
   /**
    * The invasion's string representation
-   * @returns {string}
+   * @returns {string} string representation of the invasion
    */
   toString() {
     let lines = [];
     if (this.vsInfestation) {
       lines = [
-        this.defenderReward.toString(),
+        this.defender.reward?.toString(),
         `${this.desc} on ${this.node}`,
         `${Math.round(this.completion * 100) / 100}% - ETA: ${this.getETAString()}`,
-      ];
+      ].filter(Boolean);
     } else {
       lines = [
-        `${this.attackingFaction} (${this.attackerReward}) vs. ${this.defendingFaction} (${this.defenderReward})`,
+        `${this.attackingFaction} (${this.attacker.reward}) vs. ${this.defender.faction} (${this.defender.reward})`,
         `${this.node} - ${this.desc}`,
         `${Math.round(this.completion * 100) / 100}% - ETA: ${this.getETAString()}`,
       ];
     }
-    return `${this.mdConfig.codeMulti}${lines.join(this.mdConfig.lineEnd)}${this.mdConfig.blockEnd}`;
+    return `${mdConfig.codeBlock}${lines.join(mdConfig.lineEnd)}${mdConfig.blockEnd}`;
   }
 }
-
-module.exports = Invasion;