worldstate-emitter 1.0.8 → 2.0.1

package/.nvmrc

@@ -0,0 +1 @@
+lts/iron

package/README.md

@@ -2,7 +2,9 @@
 
 Suuuper simple emitter for worldstate events.
 
-Very opinionated decisions on what events and event names, as well as
+Very opinionated decisions on what events and event names, as well as.... everything else
+
+[![semantic-release: angular](https://img.shields.io/badge/semantic--release-angular-e10079?logo=semantic-release)](https://github.com/semantic-release/semantic-release)
 
 ## Emitter Events
 
@@ -91,5 +93,5 @@ Method | Params | Output
 </details>
 <br />
 
-Help & Contact
+## Help & Contact
 [![Discord](https://img.shields.io/discord/256087517353213954.svg?logo=discord)](https://discord.gg/jGZxH9f)

package/handlers/RSS.js

@@ -1,14 +1,12 @@
-'use strict';
+import RssFeedEmitter from 'rss-feed-emitter';
+import feeds from '../resources/rssFeeds.json' assert { type: 'json' };
 
-const RssFeedEmitter = require('rss-feed-emitter');
-const feeds = require('../resources/rssFeeds.json');
-
-const { logger } = require('../utilities');
+import { logger } from '../utilities/index.js';
 
 /**
  * RSS Emitter, leverages [rss-feed-emitter](https://npmjs.org/package/rss-feed-emitter)
  */
-class RSS {
+export default class RSS {
   /**
    * Set up emitting events for warframe forum entries
    * @param {EventEmitter} eventEmitter Emitter to send events from
@@ -66,5 +64,3 @@ class RSS {
     }
   }
 }
-
-module.exports = RSS;

package/handlers/Twitter.js

@@ -1,21 +1,19 @@
-'use strict';
-
-const Twitter = require('twitter');
-const toWatch = require('../resources/tweeters.json');
-
-const { logger } = require('../utilities');
+import Twitter from 'twitter';
+import toWatch from '../resources/tweeters.json' assert { type: 'json' };
+import { logger } from '../utilities/index.js';
+import { twiClientInfo, TWITTER_TIMEOUT } from '../utilities/env.js';
 
 const determineTweetType = (tweet) => {
   if (tweet.in_reply_to_status_id) {
-    return ('reply');
+    return 'reply';
   }
   if (tweet.quoted_status_id) {
-    return ('quote');
+    return 'quote';
   }
   if (tweet.retweeted_status) {
-    return ('retweet');
+    return 'retweet';
   }
-  return ('tweet');
+  return 'tweet';
 };
 
 const parseAuthor = (tweet) => ({
@@ -25,15 +23,16 @@ const parseAuthor = (tweet) => ({
   avatar: `${tweet.user.profile_image_url.replace('_normal.jpg', '.jpg')}`,
 });
 
-const parseQuoted = (tweet, type) => (tweet[type]
-  ? {
-    text: tweet[type].full_text,
-    author: {
-      name: tweet[type].user.name,
-      handle: tweet[type].user.screen_name,
-    },
-  }
-  : undefined);
+const parseQuoted = (tweet, type) =>
+  tweet[type]
+    ? {
+        text: tweet[type].full_text,
+        author: {
+          name: tweet[type].user.name,
+          handle: tweet[type].user.screen_name,
+        },
+      }
+    : undefined;
 
 const parseTweet = (tweets, watchable) => {
   const [tweet] = tweets;
@@ -55,27 +54,16 @@ const parseTweet = (tweets, watchable) => {
 /**
  * Twitter event handler
  */
-class TwitterCache {
+export default class TwitterCache {
   /**
    * Create a new Twitter self-updating cache
    * @param {EventEmitter} eventEmitter emitter to push new tweets to
    */
   constructor(eventEmitter) {
     this.emitter = eventEmitter;
-    this.timeout = process.env.TWITTER_TIMEOUT || 60000;
-    this.initTime = Date.now();
-
-    const clientInfo = {
-      consumer_key: process.env.TWITTER_KEY,
-      consumer_secret: process.env.TWITTER_SECRET,
-      bearer_token: process.env.TWITTER_BEARER_TOKEN,
-    };
-
-    this.clientInfoValid = clientInfo.consumer_key
-      && clientInfo.consumer_secret
-      && clientInfo.bearer_token;
-
-    this.initClient(clientInfo);
+    this.timeout = TWITTER_TIMEOUT;
+    this.clientInfoValid = twiClientInfo.consumer_key && twiClientInfo.consumer_secret && twiClientInfo.bearer_token;
+    this.initClient(twiClientInfo);
   }
 
   initClient(clientInfo) {
@@ -85,7 +73,7 @@ class TwitterCache {
 
         // don't attempt anything else if authentication fails
         this.toWatch = toWatch;
-        this.currentData = null;
+        this.currentData = undefined;
         this.lastUpdated = Date.now() - 60000;
         this.updateInterval = setInterval(() => this.update(), this.timeout);
         this.update();
@@ -129,19 +117,21 @@ class TwitterCache {
     logger.silly('Starting Twitter update...');
     const parsedData = [];
     try {
-      for (const watchable of this.toWatch) {
-        const tweets = await this.client.get('statuses/user_timeline', {
-          screen_name: watchable.acc_name,
-          tweet_mode: 'extended',
-          count: 1,
-        });
-        const tweet = parseTweet(tweets, watchable);
-        parsedData.push(tweet);
-
-        if (tweet.createdAt.getTime() > this.lastUpdated) {
-          this.emitter.emit('tweet', tweet);
-        }
-      }
+      await Promise.all(
+        this.toWatch.map(async (watchable) => {
+          const tweets = await this.client.get('statuses/user_timeline', {
+            screen_name: watchable.acc_name,
+            tweet_mode: 'extended',
+            count: 1,
+          });
+          const tweet = parseTweet(tweets, watchable);
+          parsedData.push(tweet);
+
+          if (tweet.createdAt.getTime() > this.lastUpdated) {
+            this.emitter.emit('tweet', tweet);
+          }
+        })
+      );
     } catch (error) {
       this.onError(error);
     }
@@ -176,5 +166,3 @@ class TwitterCache {
     return this.currentData;
   }
 }
-
-module.exports = TwitterCache;

package/handlers/Worldstate.js

@@ -1,86 +1,77 @@
-'use strict';
+import wsData from 'warframe-worldstate-data';
+import WSCache from '../utilities/WSCache.js';
+import { logger, lastUpdated } from '../utilities/index.js';
+import parseNew from './events/parse.js';
+import Cache from '../utilities/Cache.js';
 
-const Cache = require('json-fetch-cache');
-const { locales } = require('warframe-worldstate-data');
-
-const WSCache = require('../utilities/WSCache');
-
-const { logger, lastUpdated } = require('../utilities');
-
-const parseNew = require('./events/parse');
-
-const wsTimeout = process.env.CACHE_TIMEOUT || 60000;
-const platforms = ['pc', 'ps4', 'xb1', 'swi'];
-const worldStates = {};
-const wsRawCaches = {};
+const { locales } = wsData;
 
 const debugEvents = ['arbitration', 'kuva', 'nightwave'];
-const smTimeout = process.env.SEMLAR_TIMEOUT || 300000;
-const kuvaCache = new Cache('https://10o.io/arbitrations.json', smTimeout, { logger, maxRetry: 0 });
-const sentientCache = new Cache('https://semlar.com/anomaly.json', smTimeout, { logger });
+const smCron = `0 */10 * * * *`;
 
 /**
  * Handler for worldstate data
  */
-class Worldstate {
+export default class Worldstate {
+  #emitter;
+  #locale;
+  #worldStates = {};
+  #wsRawCache;
+  #kuvaCache;
+  #sentientCache;
+
   /**
    * Set up listening for specific platform and locale if provided.
    * @param {EventEmitter} eventEmitter Emitter to push new worldstate events to
-   * @param {string} platform     Platform to watch (optional)
    * @param {string} locale       Locale (actually just language) to watch
    */
-  constructor(eventEmitter, platform, locale) {
-    this.emitter = eventEmitter;
-    this.platform = platform;
-    this.locale = locale;
+  constructor(eventEmitter, locale) {
+    this.#emitter = eventEmitter;
+    this.#locale = locale;
     logger.silly('starting up worldstate listener...');
-    if (platform) {
-      logger.debug(`only listening for ${platform}...`);
-    }
     if (locale) {
       logger.debug(`only listening for ${locale}...`);
     }
+  }
 
-    this.setUpRawEmitters();
+  async init() {
+    this.#wsRawCache = await Cache.make('https://content.warframe.com/dynamic/worldState.php', '*/10 * * * * *');
+    this.#kuvaCache = await Cache.make('https://10o.io/arbitrations.json', smCron);
+    this.#sentientCache = await Cache.make('https://semlar.com/anomaly.json', smCron);
+
+    await this.setUpRawEmitters();
     this.setupParsedEvents();
   }
 
   /**
    * Set up emitting raw worldstate data
    */
-  setUpRawEmitters() {
-    platforms.forEach((p) => {
-      if (this.platform && this.platform !== p) return;
-
-      const url = `https://content${p === 'pc' ? '' : `.${p}`}.warframe.com/dynamic/worldState.php`;
-      worldStates[p] = {};
-
-      locales.forEach(async (locale) => {
-        if (!this.locale || this.locale === locale) {
-          worldStates[p][locale] = new WSCache({
-            platform: p, language: locale, kuvaCache, sentientCache, eventEmitter: this.emitter,
-          });
-        }
-      });
-
-      wsRawCaches[p] = new Cache(url, wsTimeout, {
-        delayStart: false,
-        parser: (str) => str,
-        useEmitter: true,
-        logger,
-      });
+  async setUpRawEmitters() {
+    this.#worldStates = {};
+
+    // eslint-disable-next-line no-restricted-syntax
+    for await (const locale of locales) {
+      if (!this.#locale || this.#locale === locale) {
+        this.#worldStates[locale] = new WSCache({
+          language: locale,
+          kuvaCache: this.#kuvaCache,
+          sentientCache: this.#sentientCache,
+          eventEmitter: this.#emitter,
+        });
+      }
+    }
 
-      /* listen for the raw cache updates so we can emit them from the super emitter */
-      wsRawCaches[p].on('update', (dataStr) => {
-        this.emitter.emit('ws:update:raw', { platform: p, data: dataStr });
-      });
+    /* listen for the raw cache updates so we can emit them from the super emitter */
+    this.#wsRawCache.on('update', (dataStr) => {
+      this.#emitter.emit('ws:update:raw', { platform: 'pc', data: dataStr });
     });
 
     /* when the raw emits happen, parse them and store them on parsed worldstate caches */
-    this.emitter.on('ws:update:raw', ({ platform, data }) => {
+    this.#emitter.on('ws:update:raw', ({ data }) => {
+      logger.debug('ws:update:raw - updating locales data');
       locales.forEach((locale) => {
-        if (!this.locale || this.locale === locale) {
-          worldStates[platform][locale].data = data;
+        if (!this.#locale || this.#locale === locale) {
+          this.#worldStates[locale].data = data;
         }
       });
     });
@@ -90,9 +81,9 @@ class Worldstate {
    * Set up listeners for the parsed worldstate updates
    */
   setupParsedEvents() {
-    this.emitter.on('ws:update:parsed', ({ language, platform, data }) => {
+    this.#emitter.on('ws:update:parsed', ({ language, platform, data }) => {
       const packet = { platform, worldstate: data, language };
-      this.parseEvents(packet, this.emitter);
+      this.parseEvents(packet);
     });
   }
 
@@ -100,7 +91,7 @@ class Worldstate {
    * Parse new worldstate events
    * @param  {Object} worldstate     worldstate to find packets from
    * @param  {string} platform       platform the worldstate corresponds to
-   * @param  {string} [language='en'] langauge of the worldstate (defaults to 'en')
+   * @param  {string} [language='en'] language of the worldstate (defaults to 'en')
    */
   parseEvents({ worldstate, platform, language = 'en' }) {
     const cycleStart = Date.now();
@@ -108,12 +99,16 @@ class Worldstate {
     Object.keys(worldstate).forEach(async (key) => {
       if (worldstate && worldstate[key]) {
         const packet = parseNew({
-          data: worldstate[key], key, language, platform, cycleStart,
+          data: worldstate[key],
+          key,
+          language,
+          platform,
+          cycleStart,
         });
 
         if (Array.isArray(packet)) {
           if (packet.length) {
-            packets.push(...(packet.filter((p) => p && p !== null)));
+            packets.push(...packet.filter((p) => p && p));
           }
         } else if (packet) {
           packets.push(packet);
@@ -123,7 +118,7 @@ class Worldstate {
 
     lastUpdated[platform][language] = Date.now();
     packets
-      .filter((p) => p && p.id && packets !== null)
+      .filter((p) => p && p.id && packets)
       .forEach((packet) => {
         this.emit('ws:update:event', packet);
       });
@@ -139,23 +134,20 @@ class Worldstate {
 
     logger.silly(`ws:update:event - emitting ${packet.id}`);
     delete packet.cycleStart;
-    this.emitter.emit(id, packet);
+    this.#emitter.emit(id, packet);
   }
 
   /**
    * get a specific worldstate version
-   * @param  {string} [platform='pc'] Platform of the worldstate
-   * @param  {string} [locale='en']   Locale of the worldsttate
-   * @returns {Object}                 Worldstate corresponding to provided data
+   * @param  {string} [language='en'] Locale of the worldsttate
+   * @returns {Object}                Worldstate corresponding to provided data
    * @throws {Error} when the platform or locale aren't tracked and aren't updated
    */
-  // eslint-disable-next-line class-methods-use-this
-  get(platform = 'pc', language = 'en') {
-    if (worldStates[platform] && worldStates[platform][language]) {
-      return worldStates[platform][language].data;
+  get(language = 'en') {
+    logger.warn(`getting worldstate ${language}...`);
+    if (this.#worldStates?.[language]) {
+      return this.#worldStates?.[language]?.data;
     }
-    throw new Error(`Platform (${platform}) or language (${language}) not tracked.\nEnsure that the parameters passed are correct`);
+    throw new Error(`Language (${language}) not tracked.\nEnsure that the parameters passed are correct`);
   }
 }
-
-module.exports = Worldstate;

package/handlers/events/arrayLike.js

@@ -1,6 +1,6 @@
-'use strict';
-
-const checkOverrides = require('./checkOverrides');
+import checkOverrides from './checkOverrides.js';
+import objectLike from './objectLike.js';
+import { logger } from '../../utilities/index.js';
 
 /**
  * arrayLike are all just arrays of objectLike
@@ -8,13 +8,19 @@ const checkOverrides = require('./checkOverrides');
  * @param  {Object[]} packets  packets to emit
  * @returns {Object|Object[]}  object(s) to emit from arrayLike processing
  */
-module.exports = (deps, packets) => {
-  deps.data.forEach((arrayItem) => {
-    const k = checkOverrides(deps.key, arrayItem);
-    packets.push(require('./objectLike')(arrayItem, {
-      ...deps,
-      id: k,
-    }));
-  });
-  return packets;
+export default (deps, packets) => {
+  try {
+    deps.data.forEach((arrayItem) => {
+      const k = checkOverrides(deps.key, arrayItem);
+      packets.push(
+        objectLike(arrayItem, {
+          ...deps,
+          id: k,
+        })
+      );
+    });
+    return packets;
+  } catch (err) {
+    logger.error(err);
+  }
 };

package/handlers/events/checkOverrides.js

@@ -1,6 +1,4 @@
-'use strict';
-
-const eKeyOverrides = require('./eKeyOverrides');
+import * as eKeyOverrides from './eKeyOverrides.js';
 
 /**
  * Find overrides for the provided key
@@ -8,7 +6,7 @@ const eKeyOverrides = require('./eKeyOverrides');
  * @param  {Object} data data corresponding to the key from provided worldstate
  * @returns {string}      overrided key
  */
-module.exports = (key, data) => {
+export default (key, data) => {
   if (typeof eKeyOverrides[key] === 'string') {
     return eKeyOverrides[key];
   }

package/handlers/events/cycleLike.js

@@ -1,8 +1,19 @@
-'use strict';
+import { between, lastUpdated, fromNow } from '../../utilities/index.js';
 
-const { between, lastUpdated, fromNow } = require('../../utilities');
+/**
+ * @typedef {Object} CycleLike
+ * @property {string} state
+ * @property {string} key
+ * @property {Date} activation
+ */
 
-module.exports = (cycleData, deps) => {
+/**
+ * CylceData parser
+ * @param {CycleLike} cycleData data for parsing all cycles like this
+ * @param {Deps} deps dependencies for processing
+ * @returns {Object[]}
+ */
+export default (cycleData, deps) => {
   const packet = {
     ...deps,
     data: cycleData,

package/handlers/events/eKeyOverrides.js

@@ -1,28 +1,40 @@
-'use strict';
+import { logger } from '../../utilities/index.js';
 
-const { logger } = require('../../utilities');
+/**
+ * External mission data retrieved from https://10o.io/kuvalog.json
+ * @typedef {Object} ExternalMission
+ * @property {Date} activation start time
+ * @property {Date} expiry end timer
+ * @property {string} node formatted node name with planet
+ * @property {string} enemy Enemy on tile
+ * @property {string} type Mission type of node
+ * @property {boolean} archwing whether or not the tile requires archwing
+ * @property {boolean} sharkwing whether or not the tile requires
+ *    sumbersible archwing
+ */
 
-const fissureKey = (fissure) => `fissures.t${fissure.tierNum}.${(fissure.missionType || '').toLowerCase()}`;
-const acolyteKey = (acolyte) => ({
+export const fissures = (fissure) => `fissures.t${fissure.tierNum}.${(fissure.missionType || '').toLowerCase()}`;
+export const enemies = (acolyte) => ({
   eventKey: `enemies${acolyte.isDiscovered ? '' : '.departed'}`,
   activation: acolyte.lastDiscoveredAt,
 });
-const arbiKey = (arbitration) => {
-  if (!(arbitration && arbitration.enemy)) return '';
+
+/**
+ * Parse an arbitration for its key
+ * @param {ExternalMission} arbi arbitration data to parse
+ * @returns {string}
+ */
+export const arbitration = (arbi) => {
+  if (!arbi?.enemy) return '';
 
   let k;
   try {
-    k = `arbitration.${arbitration.enemy.toLowerCase()}.${arbitration.type.replace(/\s/g, '').toLowerCase()}`;
+    k = `arbitration.${arbi.enemy.toLowerCase()}.${arbi.type.replace(/\s/g, '').toLowerCase()}`;
   } catch (e) {
-    logger.error(`Unable to parse arbitraion: ${JSON.stringify(arbitration)}\n${e}`);
+    logger.error(`Unable to parse arbitraion: ${JSON.stringify(arbi)}\n${e}`);
   }
   return k;
 };
 
-module.exports = {
-  events: 'operations',
-  persistentEnemies: 'enemies',
-  fissures: fissureKey,
-  enemies: acolyteKey,
-  arbitration: arbiKey,
-};
+export const events = 'operations';
+export const persistentEnemies = 'enemies';

package/handlers/events/kuva.js

@@ -1,14 +1,13 @@
-'use strict';
-
-const { logger, groupBy } = require('../../utilities');
+import { logger, groupBy } from '../../utilities/index.js';
+import objectLike from './objectLike.js';
 
 /**
  * Process kuva fields
- * @param  {Object} deps    dependencies for processing
+ * @param  {Deps} deps    dependencies for processing
  * @param  {Object[]} packets  packets to emit
  * @returns {Object|Object[]}  object(s) to emit from kuva stuff
  */
-module.exports = (deps, packets) => {
+export default (deps, packets) => {
   if (!deps.data) {
     logger.error('no kuva data');
     return undefined;
@@ -22,7 +21,7 @@ module.exports = (deps, packets) => {
       activation: data[type][0].activation,
       expiry: data[type][0].expiry,
     };
-    const p = require('./objectLike')(deps.data, deps);
+    const p = objectLike(deps.data, deps);
     if (p) {
       packets.push(p);
     }

package/handlers/events/nightwave.js

@@ -1,6 +1,6 @@
-'use strict';
+import objectLike from './objectLike.js';
 
-module.exports = (nightwave, deps) => {
+export default (nightwave, deps) => {
   const groups = {
     daily: [],
     weekly: [],
@@ -19,13 +19,16 @@ module.exports = (nightwave, deps) => {
 
   const packets = [];
   Object.keys(groups).forEach((group) => {
-    const p = require('./objectLike')({
-      ...nightwave,
-      activeChallenges: groups[group],
-    }, {
-      ...deps,
-      id: `nightwave.${group}`,
-    });
+    const p = objectLike(
+      {
+        ...nightwave,
+        activeChallenges: groups[group],
+      },
+      {
+        ...deps,
+        id: `nightwave.${group}`,
+      }
+    );
     packets.push(p);
   });
   return packets;

package/handlers/events/objectLike.js

@@ -1,8 +1,6 @@
-'use strict';
+import { between, lastUpdated } from '../../utilities/index.js';
 
-const { between, lastUpdated } = require('../../utilities');
-
-module.exports = (data, deps) => {
+export default (data, deps) => {
   if (!data) return undefined;
   const last = new Date(lastUpdated[deps.platform][deps.language]);
   const activation = new Date(data.activation);

package/handlers/events/parse.js

@@ -1,15 +1,24 @@
-'use strict';
+import checkOverrides from './checkOverrides.js';
+import kuvaProcessing from './kuva.js';
+import arrayLike from './arrayLike.js';
+import objectLike from './objectLike.js';
+import nightwave from './nightwave.js';
+import cycleLike from './cycleLike.js';
+import * as eKeyOverrides from './eKeyOverrides.js';
+import { lastUpdated } from '../../utilities/index.js';
 
-const checkOverrides = require('./checkOverrides');
-const kuvaProcessing = require('./kuva');
-const arrayLike = require('./arrayLike');
-const eKeyOverrides = require('./eKeyOverrides');
-
-const { lastUpdated } = require('../../utilities');
+/**
+ * @typedef {Object} Deps
+ * @property {string} key event key being parsed
+ * @property {string} platform platform the event is on
+ * @property {string} language language the event is in
+ * @property {Date} cycleStart start of the current cycle
+ * @property {Object|Array} data data to parse
+ */
 
 /**
- * Set up current cycle start if it's not been intiated
- * @param  {Object} deps    dependencies for processing
+ * Set up current cycle start if it's not been initiated
+ * @param  {Deps} deps    dependencies for processing
  */
 const initCycleStart = (deps) => {
   if (!lastUpdated[deps.platform][deps.language]) {
@@ -19,10 +28,10 @@ const initCycleStart = (deps) => {
 
 /**
  * Parse new events from the provided worldstate
- * @param  {Object} deps dependencies to parse out events
+ * @param  {Deps} deps dependencies to parse out events
  * @returns {Packet|Packet[]}      packet(s) to emit
  */
-module.exports = (deps) => {
+export default (deps) => {
   initCycleStart(deps);
 
   // anything in the eKeyOverrides goes first, then anything uniform
@@ -49,7 +58,7 @@ module.exports = (deps) => {
     case 'cetusCycle':
     case 'earthCycle':
     case 'vallisCycle':
-      packets.push(require('./cycleLike')(deps.data, deps));
+      packets.push(cycleLike(deps.data, deps));
       break;
     case 'persistentEnemies':
       deps = {
@@ -61,9 +70,9 @@ module.exports = (deps) => {
     case 'arbitration':
     case 'sentientOutposts':
       deps.id = checkOverrides(deps.key, deps.data);
-      packets.push(require('./objectLike')(deps.data, deps));
+      packets.push(objectLike(deps.data, deps));
     case 'nightwave':
-      packets.push(require('./nightwave')(deps.data, deps));
+      packets.push(nightwave(deps.data, deps));
     default:
       break;
   }

package/index.js

@@ -1,27 +1,38 @@
-'use strict';
+import EventEmitter from 'node:events';
 
-const EventEmitter = require('events');
+import RSS from './handlers/RSS.js';
+import Worldstate from './handlers/Worldstate.js';
+import Twitter from './handlers/Twitter.js';
 
-const RSS = require('./handlers/RSS');
-const Worldstate = require('./handlers/Worldstate');
-const Twitter = require('./handlers/Twitter');
+import { logger } from './utilities/index.js';
 
-const { logger } = require('./utilities');
+export default class WorldstateEmitter extends EventEmitter {
+  #locale;
+  #worldstate;
+  #twitter;
+  #rss;
+
+  static async make({ locale = 'en' } = { locale: 'en' }) {
+    const emitter = new WorldstateEmitter({ locale });
+    await emitter.#init();
+    return emitter;
+  }
 
-class WorldstateEmitter extends EventEmitter {
   /**
    * Pull in and instantiate emitters
-   * @param {string} platform platform to restrict events to
+   * @param {string} locale language to restrict events to
    */
-  constructor({ platform, locale } = { platform: undefined, locale: undefined }) {
+  constructor({ locale } = { locale: undefined }) {
     super();
 
-    this.platform = platform;
-    this.locale = locale;
+    this.#locale = locale;
+  }
 
-    this.rss = new RSS(this);
-    this.worldstate = new Worldstate(this, platform, locale);
-    this.twitter = new Twitter(this);
+  async #init() {
+    this.#rss = new RSS(this);
+    this.#worldstate = new Worldstate(this, this.#locale);
+    await this.#worldstate.init();
+    this.#twitter = new Twitter(this);
 
     logger.silly('hey look, i started up...');
     this.setupLogging();
@@ -37,7 +48,9 @@ class WorldstateEmitter extends EventEmitter {
     this.on('rss', (body) => logger.silly(`emitted: ${body.id}`));
     this.on('ws:update:raw', (body) => logger.silly(`emitted raw: ${body.platform}`));
     this.on('ws:update:parsed', (body) => logger.silly(`emitted parsed: ${body.platform} in ${body.language}`));
-    this.on('ws:update:event', (body) => logger.silly(`emitted event: ${body.id} ${body.platform} in ${body.language}`));
+    this.on('ws:update:event', (body) =>
+      logger.silly(`emitted event: ${body.id} ${body.platform} in ${body.language}`)
+    );
     this.on('tweet', (body) => logger.silly(`emitted: ${body.id}`));
   }
 
@@ -46,17 +59,16 @@ class WorldstateEmitter extends EventEmitter {
    * @returns {Object} [description]
    */
   getRss() {
-    return this.rss.feeder.list.map((i) => ({ url: i.url, items: i.items }));
+    return this.#rss.feeder.list.map((i) => ({ url: i.url, items: i.items }));
   }
 
   /**
    * Get a specific worldstate, defaulting to 'pc' for the platform and 'en' for the language
-   * @param  {string} [platform='pc'] platform to get
    * @param  {string} [language='en']   locale/languate to fetch
    * @returns {Object}                 Requested worldstate
    */
-  getWorldstate(platform = 'pc', language = 'en') {
-    return this.worldstate.get(platform, language);
+  getWorldstate(language = 'en') {
+    return this.#worldstate?.get(language);
   }
 
   /**
@@ -64,8 +76,6 @@ class WorldstateEmitter extends EventEmitter {
    * @returns {Promise} promised twitter data
    */
   async getTwitter() {
-    return this.twitter.clientInfoValid ? this.twitter.getData() : undefined;
+    return this.#twitter?.clientInfoValid ? this.twitter.getData() : undefined;
   }
 }
-
-module.exports = WorldstateEmitter;

package/package.json

@@ -1,15 +1,17 @@
 {
   "name": "worldstate-emitter",
-  "version": "1.0.8",
+  "version": "2.0.1",
   "description": "Event emitter for worldstate & other warframe events",
   "main": "index.js",
   "scripts": {
-    "test": "nyc --reporter=lcov mocha test/specs --exit",
-    "lint": "eslint index.js handlers/**.js utilities/**.js",
-    "lint:fix": "eslint index.js handlers/**.js utilities/**.js --fix",
-    "coverage": "npm test && nyc report --reporter=text-lcov | coveralls",
+    "test": "c8 mocha",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
+    "coverage": "npm test && npm run report | coveralls",
     "build-docs": "jsdoc -c jsdoc-config.json -d docs",
-    "dev": "nodemon test/tester.js"
+    "dev": "nodemon test/tester.js",
+    "postinstall": "install-peerdeps @wfcd/eslint-config@^1.3.3 -S",
+    "report": "c8 report --reporter=text-lcov"
   },
   "directories": {
     "test": "test/specs"
@@ -29,29 +31,31 @@
   "bugs": {
     "url": "https://github.com/wfcd/worldstate-emitter/issues"
   },
-  "homepage": "https://github.com/wfcd/worldstate-emitter#readme",
+  "homepage": "https://wfcd.github.io/worldstate-emitter/",
   "dependencies": {
-    "@sentry/node": "^6.9.0",
-    "colors": "^1.4.0",
-    "json-fetch-cache": "^1.2.6",
+    "cron": "^3.1.6",
     "rss-feed-emitter": "^3.2.2",
-    "twitter": "^1.7.1",
-    "warframe-worldstate-data": "^1.18.15",
-    "warframe-worldstate-parser": "^2.19.0",
-    "winston": "^3.3.3"
+    "twitter": "^1.7.1"
   },
   "devDependencies": {
+    "@wfcd/eslint-config": "^1.3.3",
+    "c8": "^9.1.0",
     "chai": "^4.3.4",
     "coveralls": "^3.1.0",
-    "eslint": "^8.2.0",
-    "eslint-config-airbnb-base": "^15.0.0",
-    "eslint-plugin-import": "^2.22.1",
-    "mocha": "^9.0.2",
-    "nodemon": "^2.0.7",
-    "nyc": "^15.1.0"
+    "install-peerdeps": "^2.0.3",
+    "mocha": "^10.0.0",
+    "nodemon": "^3.0.3"
+  },
+  "peerDependencies": {
+    "warframe-worldstate-data": "^1.x",
+    "warframe-worldstate-parser": "^2.x"
+  },
+  "optionalDependencies": {
+    "colors": "^1.4.0",
+    "winston": "^3.3.3"
   },
   "engines": {
-    "node": ">=10.19.0"
+    "node": ">= 18.19.0"
   },
   "eslintIgnore": [
     ".github/**",
@@ -60,9 +64,14 @@
     "types/**"
   ],
   "eslintConfig": {
-    "extends": "airbnb-base",
+    "extends": "@wfcd/eslint-config/esm",
+    "parser": "@babel/eslint-parser",
     "parserOptions": {
-      "sourceType": "script"
+      "sourceType": "module",
+      "ecmaVersion": 6,
+      "ecmaFeatures": {
+        "modules": true
+      }
     },
     "rules": {
       "valid-jsdoc": [
@@ -85,19 +94,29 @@
         }
       ],
       "no-underscore-dangle": "off",
-      "strict": [
+      "import/no-extraneous-dependencies": [
         "error",
-        "safe"
-      ],
-      "linebreak-style": "off",
-      "no-restricted-syntax": "off",
-      "no-await-in-loop": "off",
-      "global-require": "off",
-      "no-fallthrough": "off",
-      "no-param-reassign": "off",
-      "no-case-declarations": "off"
+        {
+          "peerDependencies": true
+        }
+      ]
     }
   },
+  "babel": {
+    "presets": [
+      "@babel/preset-env"
+    ],
+    "plugins": [
+      "@babel/plugin-proposal-class-properties",
+      "@babel/plugin-proposal-private-methods"
+    ]
+  },
+  "pre-commit": [
+    "lint",
+    "test",
+    "validate"
+  ],
+  "prettier": "@wfcd/eslint-config/prettier",
   "nodemonConfig": {
     "delay": 5000,
     "env": {
@@ -105,5 +124,18 @@
       "CACHE_TIMEOUT": 60000,
       "SEMLAR_TIMEOUT": 300000
     }
-  }
+  },
+  "mocha": {
+    "timeout": 20000,
+    "exit": true,
+    "spec": "test/specs/**/*.spec.js"
+  },
+  "c8": {
+    "reporter": [
+      "lcov",
+      "text"
+    ],
+    "skip-full": true
+  },
+  "type": "module"
 }

package/resources/rssFeeds.json

@@ -24,26 +24,6 @@
     "key": "forum.updates.switch",
     "defaultAttach": "https://i.imgur.com/eY1NkzO.png"
   },
-  {
-    "url": "https://forums.warframe.com/forum/2-pc-announcements.xml",
-    "defaultAttach": "https://i.imgur.com/CNrsc7V.png",
-    "key": "forum.announcements.pc"
-  },
-  {
-    "url": "https://forums.warframe.com/forum/151-ps4-announcements.xml",
-    "defaultAttach": "https://i.imgur.com/CNrsc7V.png",
-    "key": "forum.announcements.ps4"
-  },
-  {
-    "url": "https://forums.warframe.com/forum/252-xbox-one-announcements.xml",
-    "defaultAttach": "https://i.imgur.com/CNrsc7V.png",
-    "key": "forum.announcements.xb1"
-  },
-  {
-    "url": "https://forums.warframe.com/forum/1198-nintendo-switch-announcements.xml",
-    "defaultAttach": "https://i.imgur.com/CNrsc7V.png",
-    "key": "forum.announcements.switch"
-  },
   {
     "url": "https://forums.warframe.com/forum/170-announcements-events.xml",
     "key": "forum.news",
@@ -152,15 +132,6 @@
       "icon_url": "https://content.invisioncic.com/Mwarframe/monthly_2016_05/Pablo.thumb.png.35bb0384ef7b88e807d55ffc31af0896.png"
     }
   },
-  {
-    "url": "https://forums.warframe.com/discover/1778.xml",
-    "key": "forum.staff.connor",
-    "author": {
-      "name": "[DE]Connor",
-      "url": "https://forums.warframe.com/profile/710227-deconnor/",
-      "icon_url": "https://content.invisioncic.com/Mwarframe/monthly_2017_02/nezha_watermarked_120_by_kevin_glint-d9zkt5n.thumb.jpg.c9519505f40a304bece8eb435eb99ddd.jpg"
-    }
-  },
   {
     "url": "https://forums.warframe.com/discover/1779.xml",
     "key": "forum.staff.marcus",
@@ -169,23 +140,5 @@
       "url": "https://forums.warframe.com/profile/3443485-demarcus/",
       "icon_url": "https://content.invisioncic.com/Mwarframe/monthly_2018_01/5a55278d71caa_MarcusIIPrint.thumb.jpg.16cb689d778112333cffb6fe546b89ec.jpg"
     }
-  },
-  {
-    "url": "https://forums.warframe.com/discover/1780.xml",
-    "key": "forum.staff.george",
-    "author": {
-      "name": "[DE]George",
-      "url": "https://forums.warframe.com/profile/138665-degeorge/",
-      "icon_url": "https://content.invisioncic.com/Mwarframe/monthly_2016_02/George_Forum_Photo.thumb.png.62acd07b2b2e40831eca57a0e230a2b2.png"
-    }
-  },
-  {
-    "url": "https://forums.warframe.com/discover/1781.xml",
-    "key": "forum.staff.bear",
-    "author": {
-      "name": "[DE]Bear",
-      "url": "https://forums.warframe.com/profile/1589-debear/",
-      "icon_url": "https://content.invisioncic.com/Mwarframe/monthly_2018_02/juggerdaddy.thumb.gif.85061b940143c7310801ce00337636ac.gif"
-    }
   }
 ]

package/utilities/Cache.js

@@ -0,0 +1,59 @@
+import { EventEmitter } from 'node:events';
+import { CronJob } from 'cron';
+import { logger } from './index.js';
+
+export default class CronCache extends EventEmitter {
+  #url = undefined;
+  #pattern = '0 */10 * * * *'; // default: every 10 minutes
+  #job /** @type {CronJob} */ = undefined;
+  /** @type string */ #data = '';
+  #updating = undefined;
+  #logger = logger;
+
+  static async make(url, pattern) {
+    const cache = new CronCache(url, pattern);
+    await cache.#update();
+    return cache;
+  }
+
+  constructor(/** @type string */ url, /** @type string */ pattern) {
+    super();
+    this.#url = url;
+    if (pattern) this.#pattern = pattern;
+    this.#job = new CronJob(this.#pattern, this.#update.bind(this), undefined, true);
+    this.#job.start();
+  }
+
+  async #update() {
+    this.#updating = this.#fetch();
+    this.#logger.debug(`update starting  for ${this.#url}`);
+    try {
+      this.#data = await this.#updating;
+      return this.#updating;
+    } finally {
+      this.emit('update', this.#data);
+      this.#logger.debug(`update done for ${this.#url}`);
+      this.#updating = undefined;
+    }
+  }
+
+  async #fetch() {
+    logger.silly(`fetching... ${this.#url}`);
+    const updated = await fetch(this.#url);
+    this.#data = await updated.text();
+    return this.#data;
+  }
+
+  async get() {
+    if (this.#updating) {
+      logger.silly('returning in-progress update promise');
+      return this.#updating;
+    }
+    if (!this.#data) {
+      logger.silly('returning new update promise');
+      return this.#update();
+    }
+    logger.silly('returning cached data');
+    return this.#data;
+  }
+}

package/utilities/WSCache.js

@@ -1,35 +1,31 @@
-'use strict';
-
-const Worldstate = require('warframe-worldstate-parser');
+import Worldstate from 'warframe-worldstate-parser';
+import { logger } from './index.js';
 
 /**
  * Warframe WorldState Cache - store and retrieve current worldstate data
  */
-class WSCache {
+export default class WSCache {
+  #inner;
+  #kuvaCache;
+  #sentientCache;
+  #logger = logger;
+  #emitter;
+  /** @type string */ #platform = 'pc';
+  /** @type string */ #language;
+
   /**
    * Set up a cache checking for data and updates to a specific worldstate set
-   * @param {string}        platform      Platform to track
    * @param {string}        language      Langauge/translation to track
-   * @param {JSONCache}     kuvaCache     Cache of kuva data, provided by Semlar
-   * @param {JSONCache}     sentientCache Cache of sentient outpost data, provided by Semlar
-   * @param {Eventemitter}  eventEmitter  Emitter to push new worldstate updates to
+   * @param {Cache}     kuvaCache     Cache of kuva data, provided by Semlar
+   * @param {Cache}     sentientCache Cache of sentient outpost data, provided by Semlar
+   * @param {EventEmitter}  eventEmitter  Emitter to push new worldstate updates to
    */
-  constructor({
-    platform, language, kuvaCache, sentientCache, eventEmitter,
-  }) {
-    this.inner = null;
-    Object.defineProperty(this, 'inner', { enumerable: false, configurable: false });
-
-    this.kuvaCache = kuvaCache;
-    Object.defineProperty(this, 'kuvaCache', { enumerable: false, configurable: false });
-
-    this.sentientCache = sentientCache;
-    Object.defineProperty(this, 'sentientCache', { enumerable: false, configurable: false });
-
-    this.platform = platform;
-    this.language = language;
-
-    this.emitter = eventEmitter;
+  constructor({ language, kuvaCache, sentientCache, eventEmitter }) {
+    this.#inner = undefined;
+    this.#kuvaCache = kuvaCache;
+    this.#sentientCache = sentientCache;
+    this.#language = language;
+    this.#emitter = eventEmitter;
   }
 
   /**
@@ -37,7 +33,7 @@ class WSCache {
    * @returns {Object} Current worldstate data
    */
   get data() {
-    return this.inner;
+    return this.#inner;
   }
 
   /**
@@ -45,21 +41,22 @@ class WSCache {
    * @param  {string} newData New string data to parse
    */
   set data(newData) {
+    logger.debug(`got new data for ${this.#language}, parsing...`);
     setTimeout(async () => {
       const t = new Worldstate(newData, {
-        locale: this.language,
-        kuvaData: await this.kuvaCache.getData(),
-        sentientData: await this.sentientCache.getData(),
+        locale: this.#language,
+        kuvaData: JSON.parse(await this.#kuvaCache.get()),
+        sentientData: JSON.parse(await this.#sentientCache.get()),
       });
       if (!t.timestamp) return;
 
-      this.inner = t;
-      this.emitter.emit('ws:update:parsed', {
-        language: this.language,
-        platform: this.platform,
-        data: this.inner,
+      this.#inner = t;
+      this.#emitter.emit('ws:update:parsed', {
+        language: this.#language,
+        platform: this.#platform,
+        data: t,
       });
-    }, 1000);
+    }, 0);
   }
 
   /**
@@ -68,8 +65,6 @@ class WSCache {
    */
   set twitter(newTwitter) {
     if (!(newTwitter && newTwitter.length)) return;
-    this.inner.twitter = newTwitter;
+    this.#inner.twitter = newTwitter;
   }
 }
-
-module.exports = WSCache;

package/utilities/env.js

@@ -0,0 +1,10 @@
+// eslint-disable-next-line import/prefer-default-export
+export const LOG_LEVEL = process?.env?.LOG_LEVEL || 'error';
+
+export const twiClientInfo = {
+  consumer_key: process?.env?.TWITTER_KEY,
+  consumer_secret: process?.env?.TWITTER_SECRET,
+  bearer_token: process?.env?.TWITTER_BEARER_TOKEN,
+};
+
+export const TWITTER_TIMEOUT = process?.env?.TWITTER_TIMEOUT || 60000;

package/utilities/index.js

@@ -1,24 +1,25 @@
-'use strict';
+import 'colors';
 
-require('colors');
-const { transports, createLogger, format } = require('winston');
+import { transports, createLogger, format } from 'winston';
+import { LOG_LEVEL } from './env.js';
 
-const {
-  combine, label, printf, colorize,
-} = format;
+let tempLogger;
+try {
+  const { combine, label, printf, colorize } = format;
 
-/* Logger setup */
-const transport = new transports.Console({ colorize: true });
-const logFormat = printf((info) => `[${info.label}] ${info.level}: ${info.message}`);
-const logger = createLogger({
-  format: combine(
-    colorize(),
-    label({ label: 'WS'.brightBlue }),
-    logFormat,
-  ),
-  transports: [transport],
-});
-logger.level = process.env.LOG_LEVEL || 'error';
+  /* Logger setup */
+  const transport = new transports.Console({ colorize: true });
+  const logFormat = printf((info) => `[${info.label}] ${info.level}: ${info.message}`);
+  tempLogger = createLogger({
+    format: combine(colorize(), label({ label: 'WS'.brightBlue }), logFormat),
+    transports: [transport],
+  });
+  tempLogger.level = LOG_LEVEL;
+} catch (e) {
+  tempLogger = console;
+}
+
+export const logger = tempLogger;
 
 /**
  * Group an array by a field value
@@ -26,7 +27,7 @@ logger.level = process.env.LOG_LEVEL || 'error';
  * @param  {string} field field to group by
  * @returns {Object}       [description]
  */
-const groupBy = (array, field) => {
+export const groupBy = (array, field) => {
   const grouped = {};
   if (!array) return undefined;
   array.forEach((item) => {
@@ -47,7 +48,7 @@ const allowedDeviation = 30000;
  * @param  {Date} c The third Date, should be the start time of this update cycle
  * @returns {boolean}   if the event date is between the server start time and the last update time
  */
-const between = (a, b, c = new Date()) => (b + allowedDeviation > a) && (b - allowedDeviation < c);
+export const between = (a, b, c = new Date()) => b + allowedDeviation > a && b - allowedDeviation < c;
 
 /**
  * Returns the number of milliseconds between now and a given date
@@ -55,7 +56,7 @@ const between = (a, b, c = new Date()) => (b + allowedDeviation > a) && (b - all
  * @param   {function} [now] A function that returns the current UNIX time in milliseconds
  * @returns {number}
  */
-function fromNow(d, now = Date.now) {
+export function fromNow(d, now = Date.now) {
   return new Date(d).getTime() - now();
 }
 
@@ -63,7 +64,7 @@ function fromNow(d, now = Date.now) {
  * Map of last updated dates/times
  * @type {Object}
  */
-const lastUpdated = {
+export const lastUpdated = {
   pc: {
     en: 0, // Date.now(),
   },
@@ -77,11 +78,3 @@ const lastUpdated = {
     en: Date.now(),
   },
 };
-
-module.exports = {
-  logger,
-  groupBy,
-  fromNow,
-  between,
-  lastUpdated,
-};