warframe-worldstate-data 2.25.0 → 3.0.0

package/dist/types-Clh1x9kB.d.ts

@@ -0,0 +1,94 @@
+//#region types.d.ts
+interface Arcane {
+  regex: string;
+  name: string;
+  effect: string;
+  rarity: string;
+  location: string;
+  thumbnail: string;
+}
+interface ArchonShard {
+  value: string;
+  upgradeTypes: Record<string, {
+    value: string;
+  }>;
+}
+interface Conclave {
+  modes: Record<string, {
+    value: string;
+  }>;
+  categories: Record<string, {
+    value: string;
+    description: string;
+  }>;
+  challenges: Record<string, {
+    title: string;
+    description: string;
+    standing: number;
+  }>;
+  affectors: Record<string, {
+    title: string;
+    description: string;
+    standing: number;
+  }>;
+}
+interface Events {
+  tags: Record<string, {
+    value: string;
+  }>;
+  scoreVariables: Record<string, {
+    value: {
+      value: string;
+    };
+  }>;
+  scoreMaxTags: Record<string, {
+    value: {
+      value: string;
+    };
+  }>;
+}
+interface SteelPath {
+  rotation: SteelPathOffering[];
+  evergreen: SteelPathOffering[];
+}
+interface SteelPathOffering {
+  name: string;
+  cost: string;
+}
+interface SynthesisTarget {
+  name: string;
+  locations: SynthesisTargetLocation[];
+}
+interface SynthesisTargetLocation {
+  last_verified: string;
+  level: string;
+  spawn_rate: string;
+  mission: string;
+  planet: string;
+  type: string;
+  faction: string;
+}
+interface SolNode {
+  value: string;
+  enemy: string;
+  type: string;
+}
+interface SortieEndState {
+  bossName: string;
+  regions: {
+    name: string;
+    missions: string[];
+  }[];
+}
+interface SortieData {
+  modifierTypes: Record<string, string>;
+  modifierDescriptions: Record<string, string>;
+  bosses: Record<string, {
+    name: string;
+    faction: string;
+  }>;
+  endStates: SortieEndState[];
+  modifiers: string[];
+}
+//#endregion
+export { Arcane, ArchonShard, Conclave, Events, SolNode, SortieData, SteelPath, SynthesisTarget };

package/dist/types.d.ts

@@ -0,0 +1,2 @@
+import { Arcane, ArchonShard, Conclave, Events, SolNode, SortieData, SteelPath, SynthesisTarget } from "./types-Clh1x9kB.js";
+export { Arcane, ArchonShard, Conclave, Events, SolNode, SortieData, SteelPath, SynthesisTarget };

package/exports.ts

@@ -0,0 +1,153 @@
+import safeImport from './safeImport';
+import { Arcane, ArchonShard, Conclave, Events, SolNode, SortieData, SteelPath, SynthesisTarget } from './types';
+
+export type Locale = 'de' | 'en' | 'es' | 'fr' | 'it' | 'ko' | 'pl' | 'pt' | 'ru' | 'zh' | 'cs' | 'sr' | 'uk';
+
+const locales: Locale[] = ['de', 'es', 'fr', 'it', 'ko', 'pl', 'pt', 'ru', 'zh', 'cs', 'sr', 'uk'];
+
+/**
+ * Bundles all the data for a particular language
+ */
+export interface WorldstateLangBundle {
+  /**
+   * Deprecated: Array of arcane data
+   */
+  arcanes: Arcane[];
+  /**
+   * Data for Archon shard colors
+   */
+  archonShards: Record<string, ArchonShard>;
+  /**
+   * Data for translating PvP categories and types
+   */
+  conclave: Conclave;
+  /**
+   * Deprecated: Data for converting event tags to useable event data.
+   * Deprecated in favor of keeping values in languages.json
+   */
+  events: Events;
+  /**
+   * Faction universal name to plain-usage name
+   */
+  factions: Record<string, { value: string }>;
+  /**
+   * Map of fissures to "Warframeified" tier names and numbers
+   */
+  fissureModifiers: Record<string, { value: string; num: number }>;
+  /**
+   * Map of "internal" Warframe strings to useable language strings
+   */
+  languages: Record<string, { value: string; desc: string }>;
+  /**
+   * Map of Mission Type identifiers to their corresponding values
+   */
+  missionTypes: Record<string, { value: string }>;
+  /**
+   * Global modifiers for applying operations to things like
+   * credits, affinity, etc.
+   */
+  operationTypes: Record<string, { value: string; symbol: string }>;
+  /**
+   * Region mapping for indicies to planets
+   */
+  persistentEnemy: { regions: string[] };
+  /**
+   * Nodes in the Sol system, with enemy type and node information
+   */
+  solNodes: Record<string, SolNode>;
+  /**
+   * Sortie-specific mapping for modifier type, description, and boss
+   */
+  sortie: SortieData;
+  /**
+   * Steel Path mission type translations
+   */
+  steelPath: SteelPath;
+  /**
+   * Syndicate data
+   */
+  syndicates: Record<string, { name: string }>;
+  /**
+   * Synthesis target data for optimal locations to find targets.
+   */
+  synthTargets: SynthesisTarget[];
+  /**
+   * Official tutorials.
+   * Not many have been released in a long time.
+   */
+  tutorials: { regex: string; name: string; url: string }[];
+  /**
+   * Global upgrade types that are modified by #operationTypes
+   */
+  upgradeTypes: Record<string, { value: string }>;
+}
+
+const makeBundle = async () => {
+  /**
+   * English United States translations bundle,
+   *  default translations
+   * @type {WorldstateLangBundle}
+   */
+  const enUS: WorldstateLangBundle = {
+    arcanes: await safeImport('./data/arcanes.json'),
+    archonShards: await safeImport('./data/archonShards.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 */
+
+  type WorldstateData = WorldstateLangBundle & {
+    [K in Locale]?: WorldstateLangBundle;
+  } & { locales: Locale[] };
+
+  const bundle: WorldstateData = {
+    en: enUS,
+    ...enUS,
+    locales
+  };
+
+  // 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),
+      archonShards: await safeImport(`./data/${locale}/archonShards.json`, enUS.archonShards),
+      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;
+};
+
+export default await makeBundle();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "warframe-worldstate-data",
-  "version": "2.25.0",
+  "version": "3.0.0",
   "description": "Warframe data for use with warframe-worldstate-parser",
   "keywords": [
     "warframe-worldstate",
@@ -39,47 +39,60 @@
   ],
   "type": "module",
   "exports": {
-    ".": "./exports.js",
-    "./utilities": "./tools/utilities.js"
+    ".": "./dist/exports.js",
+    "./utilities": "./dist/tools/utilities.js",
+    "./types": "./dist/types.js"
   },
-  "main": "exports.js",
+  "main": "./dist/exports.js",
   "directories": {
     "test": "test"
   },
   "scripts": {
+    "build": "tsdown",
     "coverage": "npm test && c8 report --reporter=text-lcov | coveralls",
-    "lint": "eslint --ignore-path .gitignore .",
-    "lint:fix": "eslint --ignore-path .gitignore . --fix",
+    "lint": "biome lint",
+    "lint:fix": "biome lint --write",
     "prepare": "husky && npx install-peerdeps @wfcd/eslint-config@latest -S",
-    "sort": "./tools/sortLanguages.js",
+    "prepublishOnly": "npm run build",
+    "sort": "tsx ./tools/sortLanguages.ts",
     "test": "c8 mocha",
     "validate": "npm run lint:fix && npm run test && git add -u ."
   },
   "prettier": "@wfcd/eslint-config/prettier",
+  "overrides": {
+    "sinon-chai": {
+      "chai": "^5.0.3"
+    }
+  },
   "devDependencies": {
+    "@biomejs/biome": "2.0.6",
     "@commitlint/cli": "^19.2.1",
     "@commitlint/config-conventional": "^19.1.0",
     "@types/chai": "^5.0.0",
-    "@types/chai-json-schema": "^1.4.9",
-    "c8": "^10.1.2",
-    "chai": "^5.0.3",
+    "@types/mocha": "^10.0.10",
+    "@types/node": "^24.0.7",
+    "@types/sinon": "^17.0.4",
+    "@types/sinon-chai": "^4.0.0",
+    "@types/yargs": "^17.0.33",
+    "ajv": "^8.17.1",
+    "ajv-formats": "^3.0.1",
+    "c8": "^10.1.3",
+    "chai": "^5.2.0",
     "chai-json": "^1.0.0",
     "chai-json-schema-ajv": "^5.2.4",
     "coveralls": "^3.1.1",
     "husky": "^9.0.11",
     "lint-staged": "^16.0.0",
-    "mocha": "^11.0.1",
-    "prettier": "^3.2.5",
+    "mocha": "^11.7.1",
+    "prettier": "^3.6.2",
     "sinon": "^21.0.0",
     "sinon-chai": "^4.0.0",
-    "yargs": "^18.0.0"
+    "tsdown": "^0.12.9",
+    "tsx": "^4.20.3",
+    "typescript": "^5.8.3",
+    "yargs": "^17.7.2"
   },
   "engines": {
     "node": ">=18.19.0"
-  },
-  "overrides": {
-    "sinon-chai": {
-      "chai": "^5.0.3"
-    }
   }
 }

package/{safeImport.js → safeImport.ts}

@@ -1,19 +1,23 @@
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+
 /**
  * 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 = {}) => {
+const safeImport = async <T>(path: string, fallback: T = {} as T): Promise<T> => {
   try {
-    const mod = await import(path, path.includes('.json') ? { with: { type: 'json' } } : {});
-    if (mod?.default) return mod.default;
-    return mod;
+    const mod: any = await import(path, path.includes('.json') ? { with: { type: 'json' } } : {});
+    if (mod?.default) return mod.default as T;
+    return mod as T;
   } 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;
   }
 };

package/tools/integrity.ts

@@ -0,0 +1,16 @@
+/**
+ * @description Insist that the provided data has the required properties.
+ * @param thing to encourage to have data
+ * @param args arguments to ensure
+ */
+export const insist = (thing: Record<string, unknown>, ...args: string[]) => {
+  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/sortLanguages.ts

@@ -0,0 +1,44 @@
+#!/usr/bin/env node
+
+import { readFile, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import yargs from 'yargs/yargs';
+
+const options = yargs(process.argv)
+  .usage('Usage -c')
+  .option('c', { alias: 'check', describe: "Check only, don't write file", type: 'boolean', demandOption: false })
+  .parse();
+
+const checkOnly = (await options).c;
+
+const dirName: string = dirname(fileURLToPath(import.meta.url));
+const sort = (obj: Record<string, { value: string; desc?: string }>) => {
+  return Object.keys(obj)
+    .sort()
+    .reduce(
+      function (result, key: string) {
+        result[key] = obj[key];
+        return result;
+      },
+      {} as Record<string, { value: string; desc?: string }>
+    );
+};
+
+const dataDir = join(dirName, '..', 'data');
+const data = JSON.parse(await readFile(join(dataDir, 'languages.json'), 'utf8'));
+
+const sortedData = sort(data);
+
+if (JSON.stringify(sortedData, undefined, 2) !== JSON.stringify(data, undefined, 2)) {
+  console.error('Data not sorted');
+  if (checkOnly) { process.exit(1); }
+}
+
+if (checkOnly) { process.exit(0); }
+
+await writeFile(join(dataDir, 'languages.json.bak'), JSON.stringify(data, undefined, 2));
+await writeFile(join(dataDir, 'languages.json'), JSON.stringify(sortedData, undefined, 2));
+
+console.log('language.json has been sorted!');

package/tools/{timeDate.js → timeDate.ts}

@@ -1,10 +1,10 @@
-const epochZero = {
+const epochZero: WorldStateDate = {
   $date: {
     $numberLong: 0,
   },
 };
 
-const pieceIsSmoller = (seconds, ceiling, label, timePieces) => {
+const pieceIsSmoller = (seconds: number, ceiling: number, label: string, timePieces: string[]) => {
   if (seconds >= ceiling) {
     timePieces.push(`${Math.floor(seconds / ceiling)}${label}`);
     seconds = Math.floor(seconds) % ceiling;
@@ -16,12 +16,12 @@ const pieceIsSmoller = (seconds, ceiling, label, timePieces) => {
  * @param   {number} millis The number of milliseconds in the time delta
  * @returns {string} formatted time delta
  */
-export const timeDeltaToString = (millis) => {
+export const timeDeltaToString = (millis: number): string => {
   if (typeof millis !== 'number') {
     throw new TypeError('millis should be a number');
   }
 
-  let timePieces = [];
+  let timePieces: string[] = [];
   const prefix = millis < 0 ? '-' : '';
   let seconds = Math.abs(millis / 1000);
 
@@ -47,7 +47,7 @@ export const timeDeltaToString = (millis) => {
  * @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) => {
+export const fromNow = (d: Date, now: () => number = Date.now): number => {
   return d.getTime() - now();
 };
 
@@ -57,19 +57,23 @@ export const fromNow = (d, now = Date.now) => {
  * @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) => {
+export const toNow = (d: Date, now: () => number = Date.now): number => {
   return now() - d.getTime();
 };
 
+export interface WorldStateDate {
+  $date?: { $numberLong: number };
+}
+
 /**
  * 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) => {
+export const parseDate = (d?: WorldStateDate): Date => {
   const safeD = d || epochZero;
   const dt = safeD.$date || epochZero.$date;
-  return new Date(safeD.$date ? Number(dt.$numberLong) : 1000 * d.sec);
+  return new Date(safeD.$date ? Number(dt!.$numberLong) : 1000 * (d as {sec: number}).sec);
 };
 
 /**