warframe-worldstate-parser 2.32.0 → 3.0.1

package/lib/models/VoidTraderSchedule.js

@@ -1,8 +1,9 @@
-'use strict';
+import { parseDate } from '../utilities/timeDate.js';
+import { languageString } from '../utilities/translation.js';
 
-module.exports = class VoidTraderSchedule {
-  constructor(data, { timeDate, translator, locale }) {
-    this.expiry = timeDate.parseDate(data.Expiry);
-    this.item = translator.languageString(data.FeaturedItem, locale);
+export default class VoidTraderSchedule {
+  constructor(data, { locale = 'en' } = { locale: 'en' }) {
+    this.expiry = parseDate(data.Expiry);
+    this.item = languageString(data.FeaturedItem, locale);
   }
-};
+}

package/lib/models/WeeklyChallenge.js

@@ -1,29 +1,23 @@
-'use strict';
-
-const WorldstateObject = require('./WorldstateObject');
-const ChallengeInstance = require('./ChallengeInstance');
+import WorldstateObject from './WorldstateObject.js';
+import ChallengeInstance from './ChallengeInstance.js';
 
 /**
  * Represents a void trader
- * @extends {WorldstateObject}
+ * @augments {WorldstateObject}
  */
-class WeeklyChallenge extends WorldstateObject {
+export default class WeeklyChallenge extends WorldstateObject {
   /**
-   * @param   {Object}             data            The Void trader 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 Void trader data
    */
-  constructor(data, { timeDate, translator }) {
-    super(data, { timeDate });
+  constructor(data) {
+    super(data);
 
-    this.challenges = data.Challenges.map((challengeData) => new ChallengeInstance(challengeData, { translator }));
+    this.challenges = data.Challenges.map((challengeData) => new ChallengeInstance(challengeData));
   }
 
   /**
    * Returns a string representation of the trader
-   * @returns {string}
+   * @returns {string} string representation
    */
   toString() {
     return `Starts: ${this.getStartString()}\nEnds: ${this.getEndString()}\nChallenges:\n${this.challenges
@@ -31,5 +25,3 @@ class WeeklyChallenge extends WorldstateObject {
       .join('\n')}`;
   }
 }
-
-module.exports = WeeklyChallenge;

package/lib/models/WorldEvent.js

@@ -1,72 +1,49 @@
-'use strict';
+import { fromNow, parseDate } from '../utilities/timeDate.js';
+import { faction, languageString, node, syndicate } from '../utilities/translation.js';
+import mdConfig from '../supporting/MarkdownSettings.js';
 
-const WorldstateObject = require('./WorldstateObject');
-const SyndicateJob = require('./SyndicateJob');
+import WorldstateObject from './WorldstateObject.js';
+import SyndicateJob from './SyndicateJob.js';
+import Reward from './Reward.js';
 
 /**
  * Interim step for an event reward system.
- * @typedef {Object} InterimStep
- *
- * @property {Number} goal          Goal amount
+ * @typedef {object} InterimStep
+ * @property {number} goal          Goal amount
  * @property {Reward} reward        Reward for reaching the step
- * @property {Number} winnerCount   Amount of players at this step
- * @property {Object} message       Message received when reaching the interim step
+ * @property {number} winnerCount   Amount of players at this step
+ * @property {object} message       Message received when reaching the interim step
  */
 
 /**
  * Progress for one of multiple stages
- * @typedef {Object} ProgressStep
- *
- * @property {string} type
- * @property {Number} progressAmt
+ * @typedef {object} ProgressStep
+ * @property {string} type         Type of progress
+ * @property {number} progressAmt Amount of progress
  */
 
 /**
  * Represents an in-game special event
- *
- * @extends {WorldstateObject}
+ * @augments {WorldstateObject}
  */
-class WorldEvent extends WorldstateObject {
+export default class WorldEvent extends WorldstateObject {
   /**
-   * @param   {Object}            data            The event 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 event data
+   * @param   {object}            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 = {
-      translator,
-      mdConfig,
-      Reward,
-      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}
-     */
-    this.timeDate = timeDate;
-    Object.defineProperty(this, 'timeDate', { enumerable: false, configurable: false });
-
     /**
      * The date and time at which the event ends
      * @type {Date}
      */
-    this.expiry = timeDate.parseDate(data.Expiry);
+    this.expiry = parseDate(data.Expiry);
 
     /**
      * The event's main score goal
@@ -96,43 +73,43 @@ class WorldEvent extends WorldstateObject {
      * The faction that the players must fight in the event
      * @type {string}
      */
-    this.faction = translator.faction(data.Faction, locale);
+    this.faction = faction(data.Faction, locale);
 
     /**
      * The description of the event
      * @type {string}
      */
-    this.description = translator.languageString(data.Desc, locale);
+    this.description = languageString(data.Desc, locale);
 
     /**
      * Tooltip for the event
      * @type {?string}
      */
-    this.tooltip = translator.languageString(data.ToolTip, locale);
+    this.tooltip = languageString(data.ToolTip, locale);
 
     /**
      * The node where the event takes place
      * @type {?string}
      */
-    this.node = translator.node(data.Node, locale);
+    this.node = node(data.Node, locale);
 
     /**
      * The other nodes where the event takes place
      * @type {string[]}
      */
-    this.concurrentNodes = data.ConcurrentNodes ? data.ConcurrentNodes.map((n) => translator.node(n), locale) : [];
+    this.concurrentNodes = data.ConcurrentNodes ? data.ConcurrentNodes.map((n) => node(n), locale) : [];
 
     /**
      * The victim node
      * @type {?string}
      */
-    this.victimNode = translator.node(data.VictimNode, locale);
+    this.victimNode = node(data.VictimNode, locale);
 
     /**
      * The score description
      * @type {?string}
      */
-    this.scoreLocTag = data.Fomorian ? 'Fomorian Assault Score' : translator.languageString(data.ScoreLocTag, locale);
+    this.scoreLocTag = data.Fomorian ? 'Fomorian Assault Score' : languageString(data.ScoreLocTag, locale);
 
     /**
      * The event's rewards
@@ -150,13 +127,13 @@ class WorldEvent extends WorldstateObject {
 
     /**
      * Health remaining for the target
-     * @type {Number}
+     * @type {number}
      */
     this.health =
       typeof data.HealthPct !== 'undefined' ? Number.parseFloat(((data.HealthPct || 0.0) * 100).toFixed(2)) : undefined;
 
     if (data.JobAffiliationTag) {
-      this.affiliatedWith = translator.syndicate(data.JobAffiliationTag, locale);
+      this.affiliatedWith = syndicate(data.JobAffiliationTag, locale);
       if (data.Jobs) {
         this.jobs = (data.Jobs || []).map((j) => new SyndicateJob(j, this.expiry, opts));
         this.previousJobs = (data.PreviousJobs || []).map((j) => new SyndicateJob(j, this.expiry, opts));
@@ -165,7 +142,7 @@ class WorldEvent extends WorldstateObject {
 
     /**
      * Previous job id
-     * @type {String}
+     * @type {string}
      */
     this.previousId = (data.JobPreviousVersion || {}).$oid;
 
@@ -181,9 +158,9 @@ class WorldEvent extends WorldstateObject {
         goal: Number.parseInt(data.InterimGoals[index], 10),
         reward: reward ? new Reward(reward, opts) : undefined,
         message: {
-          sender: translator.languageString(msg.sender, locale),
-          subject: translator.languageString(msg.subject, locale),
-          message: translator.languageString(msg.message, locale),
+          sender: languageString(msg.sender, locale),
+          subject: languageString(msg.subject, locale),
+          message: languageString(msg.message, locale),
           senderIcon: msg.senderIcon,
           attachments: msg.attachments,
         },
@@ -201,14 +178,14 @@ class WorldEvent extends WorldstateObject {
     if (data.IsMultiProgress) {
       data.Types.forEach((type, index) => {
         this.progressSteps[index] = {
-          type: translator.languageString(type, locale),
+          type: languageString(type, locale),
           progressAmt: Number.parseInt(data.MultiProgress[index], 10),
         };
       });
 
       /**
        * Total of all MultiProgress
-       * @type {Number}
+       * @type {number}
        */
       this.progressTotal = Number.parseFloat(data.MultiProgress.reduce((accumulator, val) => accumulator + val));
     }
@@ -220,12 +197,12 @@ class WorldEvent extends WorldstateObject {
     this.showTotalAtEndOfMission = data.ShowTotalAtEOM;
     /**
      * Whether or not the event is personal
-     * @type {Boolean}
+     * @type {boolean}
      */
     this.isPersonal = data.Personal;
     /**
      * Whether or not the event is community
-     * @type {Boolean}
+     * @type {boolean}
      */
     this.isCommunity = data.Community;
 
@@ -233,50 +210,50 @@ class WorldEvent extends WorldstateObject {
      * Affectors for this mission
      * @type {string[]}
      */
-    this.regionDrops = (data.RegionDrops || []).map((drop) => translator.languageString(drop, locale));
+    this.regionDrops = (data.RegionDrops || []).map((drop) => languageString(drop, locale));
 
     /**
      * Archwing Drops in effect while this event is active
      * @type {string[]}
      */
-    this.archwingDrops = (data.ArchwingDrops || []).map((drop) => translator.languageString(drop, locale));
+    this.archwingDrops = (data.ArchwingDrops || []).map((drop) => languageString(drop, locale));
 
     this.asString = this.toString();
 
     /**
      * Metadata provided by DE
-     * @type {Object}
+     * @type {object}
      */
     this.metadata = JSON.parse((data.Metadata || '{}').replace('" ', '"'));
 
     /**
      * Bonuses given for completion
-     * @type {Array.<Number>}
+     * @type {Array.<number>}
      */
     this.completionBonuses = data.CompletionBonus || [];
 
     this.scoreVar = data.ScoreVar;
 
-    this.altExpiry = timeDate.parseDate(data.AltExpiry);
-    this.altActivation = timeDate.parseDate(data.AltActivation);
+    this.altExpiry = parseDate(data.AltExpiry);
+    this.altActivation = parseDate(data.AltActivation);
 
     this.nextAlt = {
-      expiry: timeDate.parseDate(data.NextAltExpiry),
-      activation: timeDate.parseDate(data.NextAltActivation),
+      expiry: parseDate(data.NextAltExpiry),
+      activation: parseDate(data.NextAltActivation),
     };
   }
 
   /**
    * Get whether or not the event has expired
-   * @returns {boolean}
+   * @returns {boolean} whether the event has expired
    */
   getExpired() {
-    return this.timeDate.fromNow(this.expiry) < 0;
+    return fromNow(this.expiry) < 0;
   }
 
   /**
    * The event's string representation
-   * @returns {string}
+   * @returns {string} the event's string representation
    */
   toString() {
     let lines = [`${this.description} : ${this.faction}`];
@@ -306,8 +283,6 @@ class WorldEvent extends WorldstateObject {
       );
     }
 
-    return lines.join(this.mdConfig.lineEnd);
+    return lines.join(mdConfig.lineEnd);
   }
 }
-
-module.exports = WorldEvent;

package/lib/models/WorldstateObject.js

@@ -1,39 +1,39 @@
-'use strict';
+import { parseDate, fromNow, timeDeltaToString } from '../utilities/timeDate.js';
+import { insist } from '../utilities/integrity.js';
 
 /**
- * @typedef {Object} Identifier
+ * @typedef {object} Identifier
  * @property {string} $id older identifier schema
  * @property {string} $oid newer global identifier schema
  */
 /**
- * @typedef {Object} LegacyTimestamp
+ * @typedef {object} LegacyTimestamp
  * @property {number} sec second-based timestamp
  */
 /**
- * @typedef {Object} Timestamp
+ * @typedef {object} Timestamp
  * @property {number} $numberLong millisecond-based timestamp
  */
 /**
- * @typedef {Object} ContentTimestamp
+ * @typedef {object} ContentTimestamp
  * @property {LegacyTimestamp|Timestamp} $date timestamp number wrapper
  */
 /**
- * @typedef {Object} BaseContentObject
- * @property {Identifier} _id
- * @property {ContentTimestamp} Activation
- * @property {ContentTimestamp} Expiry
+ * @typedef {object} BaseContentObject
+ * @property {Identifier} _id object identifier
+ * @property {ContentTimestamp} Activation activation timestamp
+ * @property {ContentTimestamp} Expiry expiry timestamp
  */
 
 /**
  * Represents a generic object from Worldstate
  */
-module.exports = class WorldstateObject {
+export default class WorldstateObject {
   /**
    * @param   {BaseContentObject} data The object data
-   * @param   {TimeDateFunctions} timeDate time date functions
-   * @param   {Translator} translator translation functions
    */
-  constructor(data, { timeDate, translator }) {
+  constructor(data) {
+    insist(data);
     /**
      * The object's id field
      * @type {Identifier.$id|Identifier.$oid}
@@ -41,23 +41,12 @@ module.exports = class WorldstateObject {
     // eslint-disable-next-line no-underscore-dangle
     this.id = data._id ? data._id.$oid || data._id.$id : undefined;
 
-    /**
-     * The time and date functions
-     * @type {TimeDateFunctions}
-     * @private
-     */
-    this.timeDate = timeDate;
-    Object.defineProperty(this, 'timeDate', { enumerable: false, configurable: false });
-
-    this.translator = translator || require('../utilities/translation');
-    Object.defineProperty(this, 'translator', { enumerable: false, configurable: false });
-
     if (data.Activation) {
       /**
        * The date and time at which the void trader arrives
        * @type {Date}
        */
-      this.activation = timeDate.parseDate(data.Activation);
+      this.activation = parseDate(data.Activation);
 
       /**
        * A string indicating how long it will take for the trader to arrive
@@ -72,7 +61,7 @@ module.exports = class WorldstateObject {
        * The date and time at which the void trader leaves
        * @type {Date}
        */
-      this.expiry = timeDate.parseDate(data.Expiry);
+      this.expiry = parseDate(data.Expiry);
     }
 
     if (data.Activation && data.Expiry) {
@@ -86,7 +75,7 @@ module.exports = class WorldstateObject {
 
   /**
    * Returns a string representation of the object
-   * @returns {string}
+   * @returns {string} basic representation from the id
    */
   toString() {
     return `id: ${this.id}`;
@@ -94,25 +83,25 @@ module.exports = class WorldstateObject {
 
   /**
    * Get whether the trader is currently active
-   * @returns {boolean}
+   * @returns {boolean} whether the trader is active
    */
   isActive() {
-    return this.timeDate.fromNow(this.activation) < 0 && this.timeDate.fromNow(this.expiry) > 0;
+    return fromNow(this.activation) < 0 && fromNow(this.expiry) > 0;
   }
 
   /**
    * Get a string indicating how long it will take for the trader to arrive
-   * @returns {string}
+   * @returns {string} time delta string from now to the start
    */
   getStartString() {
-    return this.timeDate.timeDeltaToString(this.timeDate.fromNow(this.activation));
+    return timeDeltaToString(fromNow(this.activation));
   }
 
   /**
    * Get a string indicating how long it will take for the trader to leave
-   * @returns {string}
+   * @returns {string} time delta string from now to the end
    */
   getEndString() {
-    return this.timeDate.timeDeltaToString(this.timeDate.fromNow(this.expiry));
+    return timeDeltaToString(fromNow(this.expiry));
   }
-};
+}

package/lib/models/ZarimanCycle.js

@@ -1,6 +1,7 @@
-'use strict';
+import { fromNow, timeDeltaToString } from '../utilities/timeDate.js';
+import mdConfig from '../supporting/MarkdownSettings.js';
 
-const WorldstateObject = require('./WorldstateObject');
+import WorldstateObject from './WorldstateObject.js';
 
 // This is a confirmed starting time for Corpus (in millis)
 // All faction operation should use this as a calculation point
@@ -11,79 +12,60 @@ const stateMaximum = 9000000;
 
 /**
  * Represents the current Zariman Corpus/Grineer Cycle
- * @extends {WorldstateObject}
+ * @augments {WorldstateObject}
  */
-class ZarimanCycle extends WorldstateObject {
+export default class ZarimanCycle extends WorldstateObject {
   /**
-   * @param   {Date}              bountiesEndDate The current zariman cycle expiry
-   * @param   {Object}            deps            The dependencies object
-   * @param   {MarkdownSettings}  deps.mdConfig   The markdown settings
-   * @param   {TimeDateFunctions} deps.timeDate   The time and date functions
+   * The current zariman cycle, for calculating the other fields
+   * @type {object}
+   * @private
    */
-  constructor(bountiesEndDate, { mdConfig, timeDate }) {
-    super({ _id: { $oid: 'zarimanCycle0' } }, { timeDate });
-
-    /**
-     * The markdown settings
-     * @type {MarkdownSettings}
-     * @private
-     */
-    this.mdConfig = mdConfig;
-    Object.defineProperty(this, 'mdConfig', { enumerable: false, configurable: false });
-
-    /**
-     * The end of the Zariman bounties timer, the faction changes exactly half way through
-     * @type {Date}
-     * @private
-     */
-    this.bountiesEndDate = bountiesEndDate;
-    Object.defineProperty(this, 'currentTime', { enumerable: false, configurable: false });
+  #ec;
+  /**
+   * The end of the Zariman bounties timer, the faction changes exactly half way through
+   * @type {Date}
+   * @private
+   */
+  #bountiesEndDate;
 
-    /**
-     * The time and date functions
-     * @type {TimeDateFunctions}
-     * @private
-     */
-    this.timeDate = timeDate;
-    Object.defineProperty(this, 'timeDate', { enumerable: false, configurable: false });
+  /**
+   * @param {Date} bountiesEndDate The current Zariman cycle expiry
+   */
+  constructor(bountiesEndDate) {
+    super({ _id: { $oid: 'zarimanCycle0' } });
 
-    /**
-     * The current zariman cycle, for calculating the other fields
-     * @type {Object}
-     * @private
-     */
-    const ec = this.getCurrentZarimanCycle();
-    Object.defineProperty(this, 'ec', { enumerable: false, configurable: false });
+    this.#bountiesEndDate = bountiesEndDate;
+    this.#ec = this.getCurrentZarimanCycle();
 
     /**
      * The date and time at which the event ends
      * @type {Date}
      */
-    this.expiry = ec.expiry;
+    this.expiry = this.#ec.expiry;
 
     /**
      * The date and time at which the event started
      * @type {Date}
      */
-    this.activation = new Date(ec.start);
+    this.activation = new Date(this.#ec.start);
 
     /**
      * Whether or not this it's corpus or grineer
      * @type {boolean}
      */
-    this.isCorpus = ec.isCorpus;
+    this.isCorpus = this.#ec.isCorpus;
 
     /**
      * Current cycle state. One of `corpus`, `grineer`
      * @type {string}
      */
-    this.state = ec.state;
+    this.state = this.#ec.state;
 
     /**
      * Time remaining string
      * @type {string}
      */
-    this.timeLeft = ec.timeLeft;
+    this.timeLeft = this.#ec.timeLeft;
 
     this.id = `zarimanCycle${this.expiry.getTime()}`;
 
@@ -92,18 +74,18 @@ class ZarimanCycle extends WorldstateObject {
 
   /**
    * Get whether the event has expired
-   * @returns {boolean}
+   * @returns {boolean} whether this is expired
    */
   getExpired() {
-    return this.expiry ? this.timeDate.fromNow(this.expiry) < 0 : /* istanbul ignore next */ true;
+    return this.expiry ? fromNow(this.expiry) < 0 : /* istanbul ignore next */ true;
   }
 
   getCurrentZarimanCycle() {
     const now = Date.now();
     // determine if it is corpus cycle or grineer cycle based on bounty end time
     // we subtract 5000 millis (5 seconds) to ensure the corpus/grineer calculation is correct
-    const bountiesClone = this.bountiesEndDate.getTime() - 5000;
-    const millisLeft = this.timeDate.fromNow(new Date(bountiesClone));
+    const bountiesClone = this.#bountiesEndDate.getTime() - 5000;
+    const millisLeft = fromNow(new Date(bountiesClone));
     // the following line is a modulus operation
     // this ensures that our calculation is correct if bountiesClone is before corpusTimeMillis
     // if you really care, read https://torstencurdt.com/tech/posts/modulo-of-negative-numbers/
@@ -118,7 +100,7 @@ class ZarimanCycle extends WorldstateObject {
 
     return {
       isCorpus,
-      timeLeft: this.timeDate.timeDeltaToString(millisLeft),
+      timeLeft: timeDeltaToString(millisLeft),
       expiry,
       expiresIn: millisLeft,
       state,
@@ -128,7 +110,7 @@ class ZarimanCycle extends WorldstateObject {
 
   /**
    * The event's string representation
-   * @returns {string}
+   * @returns {string} string representation
    */
   toString() {
     const lines = [
@@ -136,8 +118,6 @@ class ZarimanCycle extends WorldstateObject {
       `Time remaining until ${this.isCorpus ? 'grineer' : 'corpus'} takeover: ${this.timeLeft}`,
     ];
 
-    return lines.join(this.mdConfig.lineEnd);
+    return lines.join(mdConfig.lineEnd);
   }
 }
-
-module.exports = ZarimanCycle;

package/lib/supporting/Dependency.js

@@ -1,15 +1,6 @@
-'use strict';
-
 /**
  * Dependency Object
- * @property   {MarkdownSettings}   mdConfig   The markdown settings
- * @property   {Translator}         translator The string translator
- * @property   {TimeDateFunctions}  timeDate   The time and date functions
- * @property   {Mission}            Mission    The Mission parser
- * @property   {Reward}             Reward     The Reward parser
  * @property   {string}             locale     Locale to use for translations
- * @property   {Object}             logger     Generic logger to use if needed
+ * @property   {object}             logger     Generic logger to use if needed
  */
-class Dependency {}
-
-module.exports = Dependency;
+export default class Dependency {}

package/lib/supporting/DuviriChoice.js

@@ -1,9 +1,7 @@
-'use strict';
-
 /**
  * Single category of duviri choices
  */
-class DuviriChoice {
+export default class DuviriChoice {
   constructor(data) {
     switch (data.Category) {
       case 'EXC_NORMAL':
@@ -16,5 +14,3 @@ class DuviriChoice {
     this.choices = data.Choices;
   }
 }
-
-module.exports = DuviriChoice;