warframe-worldstate-data 3.1.24 → 3.2.0

package/dist/data/languages.json

@@ -242,12 +242,18 @@
   "/Lotus/StoreItems/Types/Recipes/Components/WeaponUtilityUnlockerBlueprint": {
     "value": "Exilus Weapon Adapter Blueprint"
   },
+  "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/DagathBlueprint": {
+    "value": "Dagath Blueprint"
+  },
   "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/DagathChassisComponent": {
     "value": "Dagath Chassis"
   },
   "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/DagathHelmetComponent": {
     "value": "Dagath Neuroptics"
   },
+  "/Lotus/StoreItems/Types/Recipes/WarframeRecipes/DagathSystemsComponent": {
+    "value": "Dagath Systems"
+  },
   "/Lotus/StoreItems/Types/Restoratives/Consumable/AssassinBait": {
     "value": "Stalker Beacon"
   },
@@ -19347,6 +19353,10 @@
     "value": "Secondary Wounds",
     "desc": "Gain 1 Puncture Status Effect every time you take damage."
   },
+  "ContaminationZone": {
+    "value": "Hold Your Breath",
+    "desc": "The entire region deals Toxin damage over time, increasing the longer players remain."
+  },
   "DecayingFlesh": {
     "value": "Permanent Injury",
     "desc": "Max health reduced each time health damage is taken"
@@ -19484,6 +19494,10 @@
     "value": "Miasmite Swarm",
     "desc": "Techrot Miasmites swarm out of the shadows throught the mission."
   },
+  "MurmurIncursion": {
+    "value": "Beyond The Wall",
+    "desc": "Murmur enemies join Scaldra and Techrot forces."
+  },
   "MutatedEnemies": {
     "value": "Parallel Evolution",
     "desc": "As the Legacyte evolves other enemies present also gain new abilities."
@@ -19611,6 +19625,10 @@
     "value": "Vampyric Liminus",
     "desc": "Slow moving, immortal, Duviri Liminus drain health and energy from allies who get too close."
   },
+  "VoidEnergyOverload": {
+    "value": "Ability Overload",
+    "desc": "Using an Ability opens a Void Rift on top of you."
+  },
   "Voidburst": {
     "value": "Postmortal Surges",
     "desc": "Slain enemies burts with Void energy."

package/dist/exports.d.mts

@@ -1,2 +1,122 @@
-import { n as WorldstateLangBundle, r as _default, t as Locale } from "./exports-Ki41SFqn.mjs";
+import { Arcane, ArchonShard, Conclave, Events, SolNode, SortieData, SteelPath, SynthesisTarget } from "./types.mjs";
+
+//#region exports.d.ts
+type Locale = 'de' | 'en' | 'es' | 'fr' | 'it' | 'ko' | 'pl' | 'pt' | 'ru' | 'zh' | 'cs' | 'sr' | 'uk';
+/**
+ * Bundles all the data for a particular language
+ */
+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;
+  }>;
+}
+declare const _default: WorldstateLangBundle & {
+  de?: WorldstateLangBundle | undefined;
+  en?: WorldstateLangBundle | undefined;
+  es?: WorldstateLangBundle | undefined;
+  fr?: WorldstateLangBundle | undefined;
+  it?: WorldstateLangBundle | undefined;
+  ko?: WorldstateLangBundle | undefined;
+  pl?: WorldstateLangBundle | undefined;
+  pt?: WorldstateLangBundle | undefined;
+  ru?: WorldstateLangBundle | undefined;
+  zh?: WorldstateLangBundle | undefined;
+  cs?: WorldstateLangBundle | undefined;
+  sr?: WorldstateLangBundle | undefined;
+  uk?: WorldstateLangBundle | undefined;
+} & {
+  locales: Locale[];
+};
+//#endregion
 export { Locale, WorldstateLangBundle, _default as default };

package/dist/exports.mjs

@@ -1,3 +1,78 @@
-import { t as exports_default } from "./exports-Dnvn5acu.mjs";
+import { safeImport } from "./safeImport.mjs";
 
+//#region exports.ts
+const locales = [
+	"de",
+	"es",
+	"fr",
+	"it",
+	"ko",
+	"pl",
+	"pt",
+	"ru",
+	"zh",
+	"cs",
+	"sr",
+	"uk"
+];
+const makeBundle = async () => {
+	/**
+	* English United States translations bundle,
+	*  default translations
+	* @type {WorldstateLangBundle}
+	*/
+	const enUS = {
+		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")
+	};
+	const bundle = {
+		en: enUS,
+		...enUS,
+		locales
+	};
+	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;
+};
+var exports_default = await makeBundle();
+
+//#endregion
 export { exports_default as default };

package/dist/safeImport.mjs

@@ -1,3 +1,19 @@
-import { t as safeImport } from "./safeImport-jQ3nFavf.mjs";
+//#region safeImport.ts
+/**
+* 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 = path.includes(".json") ? await import(path, { with: { type: "json" } }) : await import(path);
+		return "default" in mod ? mod.default : mod;
+	} catch (error) {
+		if ((process.env.LOG_LEVEL || "ERROR").toUpperCase() === "DEBUG") console.debug(`Failed to load module at ${path} ... returning fallback`);
+		return fallback;
+	}
+};
 
+//#endregion
 export { safeImport };

package/dist/tools/timeDate.d.mts

@@ -1,2 +1,77 @@
-import { a as fromNow, c as timeDeltaToString, i as dailyReset, l as toNow, n as LegacyTimestamp, o as parseDate, r as _default, s as pieceIsSmoller, t as ContentTimestamp, u as weeklyReset } from "../timeDate-CHdavm3I.mjs";
+//#region tools/timeDate.d.ts
+declare const pieceIsSmoller: (seconds: number, ceiling: number, label: string, timePieces: string[]) => {
+  seconds: number;
+  timePieces: string[];
+};
+/**
+ * @param   {number} millis The number of milliseconds in the time delta
+ * @returns {string} formatted time delta
+ */
+declare const timeDeltaToString: (millis: number) => string;
+/**
+ * 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
+ */
+declare const fromNow: (d: Date, now?: () => number) => number;
+/**
+ * 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
+ */
+declare const toNow: (d: Date, now?: () => number) => number;
+interface ContentTimestamp {
+  $date?: {
+    $numberLong: number | string;
+  };
+}
+interface LegacyTimestamp {
+  sec: number | string;
+}
+/**
+ * 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
+ */
+declare const parseDate: (d?: ContentTimestamp | LegacyTimestamp | number) => Date;
+/**
+ * Get a weekly reset timestamp
+ */
+declare const weeklyReset: (nowFunc?: () => Date) => {
+  activation: Date;
+  expiry: Date;
+};
+/**
+ * Get a daily reset timestamp
+ */
+declare const dailyReset: (nowFunc?: () => Date) => {
+  activation: Date;
+  expiry: Date;
+};
+/**
+ * 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
+ */
+declare const _default: {
+  timeDeltaToString: (millis: number) => string;
+  fromNow: (d: Date, now?: () => number) => number;
+  toNow: (d: Date, now?: () => number) => number;
+  parseDate: (d?: ContentTimestamp | LegacyTimestamp | number) => Date;
+  dailyReset: (nowFunc?: () => Date) => {
+    activation: Date;
+    expiry: Date;
+  };
+  weeklyReset: (nowFunc?: () => Date) => {
+    activation: Date;
+    expiry: Date;
+  };
+};
+//#endregion
 export { ContentTimestamp, LegacyTimestamp, dailyReset, _default as default, fromNow, parseDate, pieceIsSmoller, timeDeltaToString, toNow, weeklyReset };

package/dist/tools/timeDate.mjs

@@ -1,3 +1,113 @@
-import { a as timeDate_default, c as weeklyReset, i as pieceIsSmoller, n as fromNow, o as timeDeltaToString, r as parseDate, s as toNow, t as dailyReset } from "../timeDate-CoQsggGD.mjs";
+//#region tools/timeDate.ts
+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
+*/
+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 / 1e3);
+	({seconds, timePieces} = pieceIsSmoller(seconds, 86400, "d", timePieces));
+	({seconds, timePieces} = pieceIsSmoller(seconds, 3600, "h", timePieces));
+	({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
+*/
+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
+*/
+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
+*/
+const parseDate = (d) => {
+	const contentD = d || epochZero;
+	if (typeof contentD.$date?.$numberLong === "string") return new Date(Number.parseInt(contentD.$date.$numberLong, 10));
+	if (typeof contentD.$date?.$numberLong === "number") return new Date(contentD.$date.$numberLong);
+	const legacyD = d;
+	if (typeof legacyD.sec === "string") return /* @__PURE__ */ new Date(1e3 * Number.parseInt(legacyD.sec, 10));
+	if (typeof legacyD.sec !== "undefined") return /* @__PURE__ */ new Date(1e3 * legacyD.sec);
+	if (typeof d === "number") return new Date(d);
+	throw new Error(`Invalid date format ${d}`);
+};
+/**
+* Get a weekly reset timestamp
+*/
+const weeklyReset = (nowFunc = () => /* @__PURE__ */ new Date()) => {
+	const now = nowFunc();
+	const currentDay = now.getUTCDay();
+	const daysUntilNextMonday = currentDay === 0 ? 1 : 8 - currentDay;
+	const expiry = new Date(now.getTime());
+	expiry.setUTCDate(now.getUTCDate() + daysUntilNextMonday);
+	expiry.setUTCHours(0, 0, 0, 0);
+	const activation = new Date(expiry.getTime());
+	activation.setUTCDate(expiry.getUTCDate() - 7);
+	return {
+		activation,
+		expiry
+	};
+};
+/**
+* Get a daily reset timestamp
+*/
+const dailyReset = (nowFunc = () => /* @__PURE__ */ new Date()) => {
+	const now = nowFunc();
+	const activation = new Date(now.getTime());
+	activation.setUTCHours(0, 0, 0, 0);
+	const expiry = new Date(now.getTime());
+	expiry.setUTCDate(now.getUTCDate() + 1);
+	expiry.setUTCHours(0, 0, 0, 0);
+	return {
+		activation,
+		expiry
+	};
+};
+/**
+* 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
+*/
+var timeDate_default = {
+	timeDeltaToString,
+	fromNow,
+	toNow,
+	parseDate,
+	dailyReset,
+	weeklyReset
+};
 
+//#endregion
 export { dailyReset, timeDate_default as default, fromNow, parseDate, pieceIsSmoller, timeDeltaToString, toNow, weeklyReset };