warframe-worldstate-data 1.32.6 → 2.0.1

package/.nvmrc

@@ -1 +1 @@
-lts/gallium
+lts/hydrogen

package/README.md

@@ -24,13 +24,19 @@ npm i -S git://github.com/wfcd/warframe-worldstate-data.git
 ## Usage
 
 ```javascript
-const worldstateData = require('warframe-worldstate-data');
+import worldstateData from 'warframe-worldstate-data';
 const nodes = worldstateData.solNodes;
 
 const erpo = nodes['SolNode903'];
 const {enemy, value, type} = erpo;
 ```
 
+### Utilities
+```javascript
+import utilities from 'warframe-worldstate-data/utilities';
+const { getLanguage } = utilities;
+```
+
 ## Available data and formatting
 
 | JSON                       |    Data Accessor    | Description                                                                                                  |

package/exports.js

@@ -1,6 +1,4 @@
-'use strict';
-
-const safeRequire = require('./safeRequire');
+import safeImport from './safeImport.js';
 
 const locales = ['de', 'es', 'fr', 'it', 'ko', 'pl', 'pt', 'ru', 'zh', 'cs', 'sr', 'uk'];
 
@@ -36,6 +34,19 @@ const locales = ['de', 'es', 'fr', 'it', 'ko', 'pl', 'pt', 'ru', 'zh', 'cs', 'sr
  * @typedef {Object} Conclave
  */
 
+/**
+ * Steel Path Offering
+ * @typedef {Object} SteelPathOffering
+ * @property {string} name The item being offered
+ * @property {string} cost The cost of the item
+ */
+/**
+ * Steel Path
+ * @typedef {Object} SteelPath
+ * @property {Array<SteelPathOffering>} rotation A list of offerings for the Steel Path
+ * @property {Array<SteelPathOffering>} evergreen Constantly available list of items
+ */
+
 /**
  * Bundles all the data for a particular language
  * @typedef {Object} WorldstateLangBundle
@@ -57,70 +68,75 @@ const locales = ['de', 'es', 'fr', 'it', 'ko', 'pl', 'pt', 'ru', 'zh', 'cs', 'sr
  * @property {Object} upgradeTypes Global upgrade types that are modified by #operationTypes
  * @property {Array<SynthesisTarget>} synthTargets Synthesis target data for
  *  optimal locations to find targets.
+ * @property {Object<string, Record<'name', string>>} syndicates Syndicate data
+ * @property {SteelPath} steelPath Steel Path mission type translations
  */
 
-/* eslint-disable global-require */
-/**
- * English United States translations bundle,
- *  default translations
- * @type {WorldstateLangBundle}
- */
-const enUS = {
-  arcanes: require('./data/arcanes.json'),
-  conclave: require('./data/conclaveData.json'),
-  events: require('./data/eventsData.json'),
-  factions: require('./data/factionsData.json'),
-  fissureModifiers: require('./data/fissureModifiers.json'),
-  languages: require('./data/languages.json'),
-  missionTypes: require('./data/missionTypes.json'),
-  operationTypes: require('./data/operationTypes.json'),
-  persistentEnemy: require('./data/persistentEnemyData.json'),
-  solNodes: require('./data/solNodes.json'),
-  sortie: require('./data/sortieData.json'),
-  syndicates: require('./data/syndicatesData.json'),
-  tutorials: require('./data/tutorials.json'),
-  upgradeTypes: require('./data/upgradeTypes.json'),
-  synthTargets: require('./data/synthTargets.json'),
-  steelPath: require('./data/steelPath.json'),
-};
-/* eslint-enable global-require */
-
-const bundle = {
+const makeBundle = async () => {
   /**
-   * English United States translations
+   * English United States translations bundle,
+   *  default translations
    * @type {WorldstateLangBundle}
    */
-  en_US: enUS,
-  en: enUS,
-  ...enUS,
-  locales,
-};
+  const enUS = {
+    arcanes: await safeImport('./data/arcanes.json'),
+    conclave: await safeImport('./data/conclaveData.json'),
+    events: await safeImport('./data/eventsData.json'),
+    factions: await safeImport('./data/factionsData.json'),
+    fissureModifiers: await safeImport('./data/fissureModifiers.json'),
+    languages: await safeImport('./data/languages.json'),
+    missionTypes: await safeImport('./data/missionTypes.json'),
+    operationTypes: await safeImport('./data/operationTypes.json'),
+    persistentEnemy: await safeImport('./data/persistentEnemyData.json'),
+    solNodes: await safeImport('./data/solNodes.json'),
+    sortie: await safeImport('./data/sortieData.json'),
+    syndicates: await safeImport('./data/syndicatesData.json'),
+    tutorials: await safeImport('./data/tutorials.json'),
+    upgradeTypes: await safeImport('./data/upgradeTypes.json'),
+    synthTargets: await safeImport('./data/synthTargets.json'),
+    steelPath: await safeImport('./data/steelPath.json'),
+  };
+  /* eslint-enable global-require */
 
-locales.forEach((locale) => {
-  /**
-   * Translations bundle for $locale
-   * @type {WorldstateLangBundle}
-   */
-  bundle[locale] = {
-    arcanes: safeRequire(`./data/${locale}/arcanes.json`, []),
-    conclave: safeRequire(`./data/${locale}/conclaveData.json`, {}),
-    events: safeRequire(`./data/${locale}/eventsData.json`, {}),
-    factions: safeRequire(`./data/${locale}/factionsData.json`, {}),
-    fissureModifiers: safeRequire(`./data/${locale}/fissureModifiers.json`, {}),
-    languages: safeRequire(`./data/${locale}/languages.json`, {}),
-    missionTypes: safeRequire(`./data/${locale}/missionTypes.json`, {}),
-    operationTypes: safeRequire(`./data/${locale}/operationTypes.json`, {}),
-    persistentEnemy: safeRequire(`./data/${locale}/persistentEnemyData.json`, {}),
-    solNodes: safeRequire(`./data/${locale}/solNodes.json`, []),
-    sortie: safeRequire(`./data/${locale}/sortieData.json`, []),
-    syndicates: safeRequire(`./data/${locale}/syndicatesData.json`, []),
-    tutorials: safeRequire(`./data/${locale}/tutorials.json`, []),
-    upgradeTypes: safeRequire(`./data/${locale}/upgradeTypes.json`, []),
-    synthTargets: safeRequire(`./data/${locale}/synthTargets.json`, []),
-    steelPath: safeRequire(`./data/${locale}/steelPath.json`, []),
+  const bundle = {
+    /**
+     * English United States translations
+     * @type {WorldstateLangBundle}
+     */
+    en_US: enUS,
+    en: enUS,
+    ...enUS,
+    locales,
   };
-});
 
-locales.push('en');
+  // eslint-disable-next-line no-restricted-syntax
+  for await (const locale of locales) {
+    /**
+     * Translations bundle for $locale
+     * @type {WorldstateLangBundle}
+     */
+    bundle[locale] = {
+      arcanes: await safeImport(`./data/${locale}/arcanes.json`, enUS.arcanes),
+      conclave: await safeImport(`./data/${locale}/conclaveData.json`, enUS.conclave),
+      events: await safeImport(`./data/${locale}/eventsData.json`, enUS.events),
+      factions: await safeImport(`./data/${locale}/factionsData.json`, enUS.factions),
+      fissureModifiers: await safeImport(`./data/${locale}/fissureModifiers.json`, enUS.fissureModifiers),
+      languages: await safeImport(`./data/${locale}/languages.json`, enUS.languages),
+      missionTypes: await safeImport(`./data/${locale}/missionTypes.json`, enUS.missionTypes),
+      operationTypes: await safeImport(`./data/${locale}/operationTypes.json`, enUS.operationTypes),
+      persistentEnemy: await safeImport(`./data/${locale}/persistentEnemyData.json`, enUS.persistentEnemy),
+      solNodes: await safeImport(`./data/${locale}/solNodes.json`, enUS.solNodes),
+      sortie: await safeImport(`./data/${locale}/sortieData.json`, enUS.sortie),
+      syndicates: await safeImport(`./data/${locale}/syndicatesData.json`, enUS.syndicates),
+      tutorials: await safeImport(`./data/${locale}/tutorials.json`, enUS.tutorials),
+      upgradeTypes: await safeImport(`./data/${locale}/upgradeTypes.json`, enUS.upgradeTypes),
+      synthTargets: await safeImport(`./data/${locale}/synthTargets.json`, enUS.synthTargets),
+      steelPath: await safeImport(`./data/${locale}/steelPath.json`, enUS.steelPath),
+    };
+  }
+
+  locales.push('en');
+  return bundle;
+};
 
-module.exports = bundle;
+export default await makeBundle();

package/package.json

@@ -1,32 +1,38 @@
 {
   "name": "warframe-worldstate-data",
-  "version": "1.32.6",
+  "version": "2.0.1",
   "description": "Warframe data for use with warframe-worldstate-parser",
   "main": "exports.js",
+  "type": "module",
+  "exports": {
+    ".": "./exports.js",
+    "./utilities": "./tools/utilities.js"
+  },
   "directories": {
     "test": "test"
   },
   "devDependencies": {
-    "chai": "^4.2.0",
+    "@types/chai": "^4.3.11",
+    "@types/chai-json-schema": "^1.4.9",
+    "c8": "^9.1.0",
+    "chai": "^5.0.3",
     "chai-json": "^1.0.0",
-    "chai-json-schema": "^1.5.1",
-    "coveralls": "^3.1.0",
-    "eslint": "^6.8.0",
-    "eslint-config-airbnb-base": "^14.0.0",
-    "eslint-plugin-import": "^2.18.2",
-    "mocha": "^10.2.0",
-    "nyc": "^15.1.0",
+    "chai-json-schema-ajv": "^5.2.4",
+    "coveralls": "^3.1.1",
+    "install-peerdeps": "^3.0.3",
+    "mocha": "^10.3.0",
     "precommit-hook": "^3.0.0",
-    "sinon": "^8.1.1",
-    "sinon-chai": "^3.4.0"
+    "sinon": "^17.0.1",
+    "sinon-chai": "^3.7.0"
   },
   "scripts": {
     "lint": "eslint --ignore-path .gitignore .",
     "lint:fix": "eslint --ignore-path .gitignore . --fix",
-    "test": "nyc mocha",
-    "coverage": "npm test && nyc report --reporter=text-lcov | coveralls",
-    "sort": "python tools/sort_languages.py",
-    "validate": "npm run lint:fix && npm run test && git add -u ."
+    "test": "c8 mocha",
+    "coverage": "npm test && c8 report --reporter=text-lcov | coveralls",
+    "sort": "node tools/sort_languages.py",
+    "validate": "npm run lint:fix && npm run test && git add -u .",
+    "postinstall": "install-peerdeps @wfcd/eslint-config@^1.5.0 -S"
   },
   "repository": {
     "type": "git",
@@ -67,47 +73,34 @@
     "branch": "master"
   },
   "engines": {
-    "node": ">=8.17.0"
+    "node": ">=18.19.0"
   },
-  "eslintIgnore": [],
+  "eslintIgnore": [
+    ".github/**",
+    "docs/**",
+    "data/**"
+  ],
   "eslintConfig": {
-    "extends": "airbnb-base",
+    "extends": "@wfcd/eslint-config/esm",
+    "parser": "@babel/eslint-parser",
     "parserOptions": {
-      "sourceType": "script"
-    },
-    "rules": {
-      "valid-jsdoc": [
-        "error",
-        {
-          "requireReturn": false,
-          "requireReturnDescription": false,
-          "preferType": {
-            "String": "string",
-            "Number": "number",
-            "Boolean": "boolean",
-            "Function": "function",
-            "object": "Object",
-            "date": "Date",
-            "error": "Error"
-          },
-          "prefer": {
-            "return": "returns"
-          }
-        }
-      ],
-      "strict": [
-        "error",
-        "safe"
-      ],
-      "linebreak-style": "off",
-      "no-restricted-syntax": [
-        "off"
-      ],
-      "no-await-in-loop": "off",
-      "import/no-unresolved": 0
+      "sourceType": "module",
+      "ecmaVersion": 6,
+      "ecmaFeatures": {
+        "modules": true
+      }
     }
   },
-  "nyc": {
+  "babel": {
+    "presets": [
+      "@babel/preset-env"
+    ],
+    "plugins": [
+      "@babel/plugin-proposal-class-properties",
+      "@babel/plugin-proposal-private-methods"
+    ]
+  },
+  "c8": {
     "exclude": [
       "test/**"
     ],
@@ -117,7 +110,10 @@
     ],
     "skip-full": true
   },
-  "mocha": {},
+  "mocha": {
+    "spec": "test/**/*.spec.js"
+  },
+  "prettier": "@wfcd/eslint-config/prettier",
   "pre-commit": [
     "validate"
   ]

package/safeImport.js

@@ -0,0 +1,21 @@
+/**
+ * Safely require path, fall back to fallback if module cannot load
+ * @param  {string} path    Path to attempt to load
+ * @param  {Object} fallback fallback response if error or no module
+ * @returns {Promise<any>}         module or the default object
+ */
+const safeImport = async (path, fallback = {}) => {
+  try {
+    const mod = await import(path, path.includes('.json') ? { assert: { type: 'json' } } : {});
+    if (mod?.default) return mod.default;
+    return mod;
+  } catch (error) {
+    if ((process.env.LOG_LEVEL || 'ERROR').toUpperCase() === 'DEBUG') {
+      // eslint-disable-next-line no-console
+      console.debug(`Failed to load module at ${path} ... returning fallback`);
+    }
+    return fallback;
+  }
+};
+
+export default safeImport;

package/tools/integrity.js

@@ -0,0 +1,15 @@
+/**
+ * @description Insist that the provided data has the required properties.
+ * @param {Object} thing to encourage to have data
+ * @param {string[]} args arguments to ensure
+ */
+/* eslint-disable-line import/prefer-default-export */ export const insist = (thing, ...args) => {
+  if (!thing || !Object.keys(thing).length) {
+    throw new TypeError(`The provided data does not have the required properties.`);
+  }
+  args.forEach((arg) => {
+    if (!thing[arg]) {
+      throw new TypeError(`The provided data does not have the required properties.`);
+    }
+  });
+};

package/tools/timeDate.js

@@ -0,0 +1,89 @@
+const epochZero = {
+  $date: {
+    $numberLong: 0,
+  },
+};
+
+const pieceIsSmoller = (seconds, ceiling, label, timePieces) => {
+  if (seconds >= ceiling) {
+    timePieces.push(`${Math.floor(seconds / ceiling)}${label}`);
+    seconds = Math.floor(seconds) % ceiling;
+  }
+  return { seconds, timePieces };
+};
+
+/**
+ * @param   {number} millis The number of milliseconds in the time delta
+ * @returns {string} formatted time delta
+ */
+export const timeDeltaToString = (millis) => {
+  if (typeof millis !== 'number') {
+    throw new TypeError('millis should be a number');
+  }
+
+  let timePieces = [];
+  const prefix = millis < 0 ? '-' : '';
+  let seconds = Math.abs(millis / 1000);
+
+  // Seconds in a day
+  ({ seconds, timePieces } = pieceIsSmoller(seconds, 86400, 'd', timePieces));
+
+  // Seconds in an hour
+  ({ seconds, timePieces } = pieceIsSmoller(seconds, 3600, 'h', timePieces));
+
+  // Seconds in a minute
+  ({ seconds, timePieces } = pieceIsSmoller(seconds, 60, 'm', timePieces));
+
+  /* istanbul ignore else */
+  if (seconds >= 0) {
+    timePieces.push(`${Math.floor(seconds)}s`);
+  }
+  return `${prefix}${timePieces.join(' ')}`;
+};
+
+/**
+ * Returns the number of milliseconds between now and a given date
+ * @param   {Date} d         The date from which the current time will be subtracted
+ * @param   {function} [now] A function that returns the current UNIX time in milliseconds
+ * @returns {number}       The number of milliseconds after the given date to now
+ */
+export const fromNow = (d, now = Date.now) => {
+  return d.getTime() - now();
+};
+
+/**
+ * Returns the number of milliseconds between a given date and now
+ * @param   {Date} d         The date that the current time will be subtracted from
+ * @param   {function} [now] A function that returns the current UNIX time in milliseconds
+ * @returns {number}        The number of milliseconds after now to the given date
+ */
+export const toNow = (d, now = Date.now) => {
+  return now() - d.getTime();
+};
+
+/**
+ * Returns a new Date constructed from a worldState date object
+ * @param {Object} d The worldState date object
+ * @returns {Date} parsed date from DE date format
+ */
+export const parseDate = (d) => {
+  const safeD = d || epochZero;
+  const dt = safeD.$date || epochZero.$date;
+  return new Date(safeD.$date ? Number(dt.$numberLong) : 1000 * d.sec);
+};
+
+/**
+ * An object containing functions to format dates and times
+ * @typedef {Record<string, Function>}           TimeDateFunctions
+ * @property {Function} timeDeltaToString - Converts a time difference to a string
+ * @property {Function} fromNow           - Returns the number of milliseconds between now and
+ *                                          a given date
+ * @property {Function} toNow             - Returns the number of milliseconds between a given
+ *                                          date and now
+ */
+export default {
+  timeDeltaToString,
+  fromNow,
+  toNow,
+  parseDate,
+};

package/tools/translation.js

@@ -0,0 +1,334 @@
+import data from '../exports.js';
+
+/**
+ * Rough Titlecase!
+ * @param {string} str string to be titlecased
+ * @returns {string} titlecased string
+ */
+export const toTitleCase = (str) => {
+  return str.replace(/\w\S*/g, (txt) => txt.charAt(0).toUpperCase() + txt.substring(1).toLowerCase());
+};
+
+/**
+ * Utility function to split the resource name and return somewhat human-readable string
+ * @param {string} str localization resource key
+ * @returns {string} human-readable string
+ */
+export const splitResourceName = (str) =>
+  str
+    .split(/([A-Z]?[^A-Z]*)/g)
+    .filter(Boolean)
+    .join(' ');
+
+export const lastResourceName = (str) => (typeof str === 'string' ? str.split?.('/').slice?.(-1)[0] : str);
+
+const i18n = (locale = 'en') => data[locale] || data;
+
+const keyInData = (key, dataOverride) => (key in i18n(dataOverride) ? i18n(dataOverride)[key] : key);
+
+/**
+ *
+ * @param {string} key - The data key
+ * @param {string} dataOverride locale for use with translation
+ * @returns {string} faction name
+ */
+export const faction = (key, dataOverride = 'en') => keyInData('factions', dataOverride)[key]?.value ?? key;
+
+const solNode = (key, thing, dataOverride = 'en') =>
+  keyInData('solNodes', dataOverride)?.[key]?.[thing] ?? lastResourceName(key) ?? key;
+
+/**
+ *
+ * @param {string} key - The data key
+ * @param {string} dataOverride locale for use with translation
+ * @returns {string} node name
+ */
+export const node = (key, dataOverride = 'en') => solNode(key, 'value', dataOverride);
+
+/**
+ *
+ * @param {string} key - The data key
+ * @param {string} dataOverride locale for use with translation
+ * @returns {string} mission type of the node
+ */
+export const nodeMissionType = (key, dataOverride = 'en') => solNode(key, 'type', dataOverride);
+/**
+ *
+ * @param {string} key - The data key
+ * @param {string} dataOverride locale for use with translation
+ * @returns {string} faction that controls the node
+ */
+export const nodeEnemy = (key, dataOverride = 'en') => {
+  return key in i18n(dataOverride).solNodes ? i18n(dataOverride).solNodes[key].enemy : lastResourceName(key) ?? key;
+};
+
+/**
+ *
+ * @param {string} key - The data key
+ * @param {string} dataOverride locale for use with translation
+ * @returns {string} localization for language string
+ */
+export const languageString = (key, dataOverride = 'en') => {
+  const lowerKey = String(key).toLowerCase();
+  return (
+    keyInData('languages', dataOverride)[lowerKey]?.value ??
+    keyInData('languages', dataOverride)[key]?.value ??
+    toTitleCase(splitResourceName(lastResourceName(String(key)))) ??
+    key
+  );
+};
+
+/**
+ *
+ * @param {string} key - The data key
+ * @param {string} dataOverride locale for use with translation
+ * @returns {string} localization for language description
+ */
+export const languageDesc = (key, dataOverride = 'en') => {
+  const lowerKey = String(key).toLowerCase();
+  return (
+    i18n(dataOverride).languages[lowerKey]?.desc ??
+    i18n(dataOverride).languages[key]?.desc ??
+    (key ? `[PH] ${toTitleCase(splitResourceName(lastResourceName(String(key))))} Desc` : key)
+  );
+};
+
+/**
+ *
+ * @param {string} key - The data key
+ * @param {string} dataOverride locale for use with translation
+ * @returns {string} translation for mission type
+ */
+export const missionType = (key, dataOverride = 'en') => {
+  const keyBased = key && typeof key === 'string' && toTitleCase((key ?? '').replace(/^MT_/, ''));
+  return key in i18n(dataOverride).missionTypes ? i18n(dataOverride).missionTypes[key].value : keyBased;
+};
+
+const conclave = (key, thing, dataOverride = 'en') => keyInData('conclave', dataOverride)?.[thing]?.[key]?.value ?? key;
+
+/**
+ *
+ * @param {string} key - The data key
+ * @param {string} dataOverride locale for use with translation
+ * @returns {string} conclave mode
+ */
+export const conclaveMode = (key, dataOverride = 'en') => conclave(key, 'modes', dataOverride);
+
+/**
+ *
+ * @param {string} key - The data key
+ * @param {string} dataOverride locale for use with translation
+ * @returns {string} conclave category
+ */
+export const conclaveCategory = (key, dataOverride = 'en') => conclave(key, 'categories', dataOverride);
+
+const fissure = (key, dataOverride = 'en') => keyInData('fissureModifiers', dataOverride)?.[key] ?? key;
+
+/**
+ *
+ * @param {string} key - The data key
+ * @param {string} dataOverride locale for use with translation
+ * @returns {string} fissure modifier data
+ */
+export const fissureModifier = (key, dataOverride = 'en') => fissure(key, dataOverride)?.value ?? key;
+
+/**
+ *
+ * @param {string} key - The data key
+ * @param {string} dataOverride locale for use with translation
+ * @returns {number | string} fissure tier
+ */
+export const fissureTier = (key, dataOverride = 'en') => fissure(key, dataOverride).num ?? key;
+
+/**
+ *
+ * @param {string} key - The data key
+ * @param {string} dataOverride locale for use with translation
+ * @returns {string} syndicate name
+ */
+export const syndicate = (key, dataOverride = 'en') => i18n(dataOverride).syndicates[key]?.value ?? key;
+
+/**
+ *
+ * @param {string} key - The data key
+ * @param {string} dataOverride locale for use with translation
+ * @returns {string} upgrade type
+ */
+export const upgrade = (key, dataOverride = 'en') => i18n(dataOverride).upgradeTypes[key]?.value ?? key;
+
+const oppo = (key, dataOverride = 'en') => i18n(dataOverride).operationTypes[key];
+
+/**
+ *
+ * @param {string} key - The data key
+ * @param {string} dataOverride locale for use with translation
+ * @returns {string} mathematical operation value
+ */
+export const operation = (key, dataOverride = 'en') => oppo(key, dataOverride)?.value ?? key;
+
+/**
+ *
+ * @param {string} key - The data key
+ * @param {string} dataOverride locale for use with translation
+ * @returns {string} symbol of mathematical operation
+ */
+export const operationSymbol = (key, dataOverride = 'en') => oppo(key, dataOverride)?.symbol ?? key;
+
+const sortie = (key, dataOverride = 'en') => i18n(dataOverride).sortie.bosses[key];
+
+/**
+ * @param {string} key - The data key
+ * @param {string} dataOverride locale for use with translation
+ * @returns {string} sortie boss name
+ */
+export const sortieBoss = (key, dataOverride = 'en') => sortie(key, dataOverride)?.name ?? key;
+
+/**
+ * @param {string} key - The data key
+ * @param {string} dataOverride locale for use with translation
+ * @returns {string} faction for a sortie based on the boss
+ */
+export const sortieFaction = (key, dataOverride = 'en') => sortie(key, dataOverride)?.faction ?? key;
+
+/**
+ *
+ * @param {string} key - The data key
+ * @param {string} dataOverride locale for use with translation
+ * @returns {string} sortie modifier data
+ */
+export const sortieModifier = (key, dataOverride = 'en') => i18n(dataOverride).sortie.modifierTypes?.[key] ?? key;
+
+/**
+ * @param {string} key - The data key
+ * @param {string} dataOverride locale for use with translation
+ * @returns {string} sortie modifier description
+ */
+export const sortieModDesc = (key, dataOverride = 'en') => i18n(dataOverride).sortie.modifierDescriptions?.[key] ?? key;
+
+/**
+ * Retrieve the localized region for a given key
+ * @param {string | number} key - The region key
+ * @param {string} dataOverride - The locale to use for translations
+ * @returns {string} localized region name
+ */
+export const region = (key, dataOverride = 'en') => (key && i18n(dataOverride).persistentEnemy?.regions[key]) ?? key;
+
+/**
+ * Retrieve conclave challenge name for the given key and locale
+ * @param {string} key key to retrieve
+ * @param {string} dataOverride locale key override
+ * @returns {string} - The conclave challenge name for the given key
+ */
+export const conclaveChallenge = (key, dataOverride = 'en') => {
+  const splitKey = lastResourceName(String(key));
+
+  if (i18n(dataOverride).conclave?.challenges?.[splitKey]) {
+    return i18n(dataOverride).conclave.challenges[splitKey];
+  }
+  return {
+    title: toTitleCase(splitResourceName(splitKey)),
+    description: toTitleCase(splitResourceName(splitKey)),
+    standing: 0,
+  };
+};
+
+/**
+ * Get the steel path data for given key
+ * @param {string} dataOverride - The locale to use for translations
+ * @returns {string} - The steel path data for the given key
+ */
+export const steelPath = (dataOverride = 'en') => (i18n(dataOverride) || /* istanbul ignore next */ data).steelPath;
+
+const valMapping = (key, map) => {
+  let val = 'None';
+  Object.keys(map).forEach((k) => {
+    if (key.includes(k)) {
+      val = map[k];
+    }
+  });
+  return val;
+};
+
+const focusMap = {
+  'Focus/Attack': 'Madurai',
+  'Focus/Defense': 'Varazin',
+  'Focus/Tactic': 'Naramon',
+  'Focus/Power': 'Zenurik',
+  'Focus/Ward': 'Unairu',
+};
+/**
+ * Translate the given focus school
+ * @param {string} focus The focus school to translate
+ * @returns {string} The translated focus school
+ */
+export const translateFocus = (focus = '') => valMapping(focus, focusMap);
+
+const polarityMap = {
+  AP_ATTACK: 'Madurai',
+  AP_DEFENSE: 'Varazin',
+  AP_TACTIC: 'Naramon',
+  AP_POWER: 'Zenurik',
+  AP_WARD: 'Unairu',
+};
+
+/**
+ * Translate the given polarity
+ * @param {string?} pol The polarity to translate
+ * @returns {string} The translated polarity
+ */
+export const translatePolarity = (pol = '') => valMapping(pol, polarityMap);
+
+/**
+ * An object containing functions to convert in-game names to their localizations
+ * @typedef {Record<string, function>} Translator
+ * @property {function} faction          - Converts faction names
+ * @property {function} node             - Converts star map node names
+ * @property {function} nodeMissionType  - Returns the mission type of given node
+ * @property {function} nodeEnemy        - Returns the faction that controls a given node
+ * @property {function} languageString   - Converts generic language strings
+ * @property {function} languageDesc     - Converts generic language strings
+ *                                          and retrieves the description
+ * @property {function} missionType      - Converts mission types
+ * @property {function} conclaveMode     - Converts conclave modes
+ * @property {function} conclaveCategory - Converts conclave challenge categories
+ * @property {function} fissureModifier  - Converts fissure mission modifiers
+ * @property {function} syndicate        - Converts syndicate names
+ * @property {function} upgrade          - Converts upgrade types
+ * @property {function} operation        - Converts operation types
+ * @property {function} sortieBoss       - Converts sortie boss names
+ * @property {function} sortieModifier    - Converts sortie modifier types
+ * @property {function} sortieModDesc    - Converts sortie modifier type descriptions
+ * @property {function} region           - Converts persistent enemy region indicies
+ * @property {function} conclaveChallenge - Convert conclave identifiers into standing data
+ * @property {function} steelPath        -  Retrieve Steel Path rotation data for locale
+ * @property {function} toTitleCase      - Format provided string as titlecase
+ * @property {function} translateFocus   - Translate focus schools
+ * @property {function} translatePolarity - Translate polarities
+ */
+export default {
+  faction,
+  node,
+  nodeMissionType,
+  nodeEnemy,
+  languageString,
+  languageDesc,
+  missionType,
+  conclaveMode,
+  conclaveCategory,
+  fissureModifier,
+  fissureTier,
+  syndicate,
+  upgrade,
+  operation,
+  operationSymbol,
+  sortieBoss,
+  sortieModifier,
+  sortieModDesc,
+  sortieFaction,
+  region,
+  conclaveChallenge,
+  steelPath,
+  toTitleCase,
+  translateFocus,
+  translatePolarity,
+};

package/tools/utilities.js

@@ -0,0 +1,3 @@
+export * from './integrity.js';
+export * from './timeDate.js';
+export * from './translation.js';

package/safeRequire.js

@@ -1,22 +0,0 @@
-'use strict';
-
-/**
- * Safely require path, fall back to fallback if module cannot loa
- * @param  {[type]} path    Path to attempt to load
- * @param  {[type]} fallback [description]
- * @returns {any}         module or the default object
- */
-const safeRequire = (path, fallback = {}) => {
-  try {
-    // eslint-disable-next-line global-require, import/no-dynamic-require
-    return require(path);
-  } catch (error) {
-    if ((process.env.LOG_LEVEL || 'ERROR').toUpperCase() === 'DEBUG') {
-      // eslint-disable-next-line no-console
-      console.debug(`Failed to load module at ${path} ... returning fallback`);
-    }
-    return fallback;
-  }
-};
-
-module.exports = safeRequire;