warframe-worldstate-parser 4.6.2 → 5.0.1

package/dist/SortieVariant-BFkYiBho.d.ts

@@ -0,0 +1,49 @@
+import { Dependency } from "./Dependency-DkOHLql6.js";
+
+//#region lib/models/SortieVariant.d.ts
+interface RawSortieVariant {
+  missionType: string;
+  modifierType: string;
+  node: string;
+}
+/**
+ * Represents a sortie variant
+ * @class
+ */
+declare class SortieVariant {
+  /**
+   * The variant's mission type
+   */
+  missionType: string;
+  /**
+   * The variant's mission type unlocalized
+   */
+  missionTypeKey: string;
+  /**
+   * The mission modifier
+   */
+  modifier: string;
+  /**
+   * The variant's modifier description
+   */
+  modifierDescription: string;
+  /**
+   * The node where the variant takes place
+   */
+  node: string;
+  /**
+   * The node where the variant takes place unlocalized
+   */
+  nodeKey: string;
+  /**
+   * Make the SortieVariant
+   * @param data Sortie variant data
+   * @param deps Dependencies
+   * @param deps.locale Locale to use for translations
+   */
+  constructor(data: RawSortieVariant, {
+    locale
+  }?: Dependency);
+}
+//#endregion
+export { RawSortieVariant, SortieVariant };

package/dist/SortieVariant-eWuI1uh9.js

@@ -0,0 +1,51 @@
+import { insist, missionType, node, sortieModDesc, sortieModifier } from "warframe-worldstate-data/utilities";
+
+//#region lib/models/SortieVariant.ts
+/**
+* Represents a sortie variant
+* @class
+*/
+var SortieVariant = class {
+	/**
+	* The variant's mission type
+	*/
+	missionType;
+	/**
+	* The variant's mission type unlocalized
+	*/
+	missionTypeKey;
+	/**
+	* The mission modifier
+	*/
+	modifier;
+	/**
+	* The variant's modifier description
+	*/
+	modifierDescription;
+	/**
+	* The node where the variant takes place
+	*/
+	node;
+	/**
+	* The node where the variant takes place unlocalized
+	*/
+	nodeKey;
+	/**
+	* Make the SortieVariant
+	* @param data Sortie variant data
+	* @param deps Dependencies
+	* @param deps.locale Locale to use for translations
+	*/
+	constructor(data, { locale = "en" } = { locale: "en" }) {
+		insist({ ...data });
+		this.missionType = missionType(data.missionType, locale);
+		this.missionTypeKey = missionType(data.missionType, "en");
+		this.modifier = sortieModifier(data.modifierType, locale);
+		this.modifierDescription = sortieModDesc(data.modifierType, locale);
+		this.node = node(data.node, locale);
+		this.nodeKey = node(data.node, "en");
+	}
+};
+
+//#endregion
+export { SortieVariant };

package/dist/SteelPathOffering-DyAzr3P9.js

@@ -0,0 +1,85 @@
+import { steelPath, timeDeltaToString } from "warframe-worldstate-data/utilities";
+
+//#region lib/models/SteelPathOffering.ts
+const monday = 1;
+/**
+* Gets the first day of the week
+*/
+function getFirstDayOfWeek() {
+	const resultDate = /* @__PURE__ */ new Date();
+	/* istanbul ignore next */
+	const offset = resultDate.getUTCDay() === 0 ? 6 : resultDate.getUTCDay() - monday;
+	resultDate.setUTCDate(resultDate.getUTCDate() - offset);
+	resultDate.setUTCHours(0);
+	resultDate.setUTCMinutes(0);
+	resultDate.setUTCSeconds(0);
+	resultDate.setUTCMilliseconds(0);
+	return resultDate;
+}
+/**
+* Get the last day of the week
+*/
+function getLastDayOfWeek() {
+	const last = new Date(getFirstDayOfWeek());
+	last.setUTCDate(last.getUTCDate() + 6);
+	last.setUTCHours(23);
+	last.setUTCMinutes(59);
+	last.setUTCSeconds(59);
+	last.setUTCMilliseconds(0);
+	return last;
+}
+/**
+* When was the start of the day
+*/
+function getStartOfDay() {
+	const today = /* @__PURE__ */ new Date();
+	today.setUTCHours(0);
+	today.setUTCMinutes(0);
+	today.setUTCSeconds(0);
+	today.setUTCMilliseconds(0);
+	return today;
+}
+/**
+* When was the end of the day
+*/
+function getEndOfDay() {
+	const last = /* @__PURE__ */ new Date();
+	last.setUTCHours(23);
+	last.setUTCMinutes(59);
+	last.setUTCSeconds(59);
+	last.setUTCMilliseconds(0);
+	return last;
+}
+/**
+* Start of Steel Path cycle calculations
+*/
+const start = /* @__PURE__ */ new Date("2020-11-16T00:00:00.000Z");
+var SteelPathOfferings = class {
+	currentReward;
+	activation;
+	expiry;
+	remaining;
+	rotation;
+	evergreens;
+	incursions;
+	constructor({ locale }) {
+		const sSinceStart = (Date.now() - start.getTime()) / 1e3;
+		const eightWeeks = 4838400;
+		const sevenDays = 604800;
+		const ind = Math.floor(sSinceStart % eightWeeks / sevenDays);
+		this.currentReward = steelPath(locale).rotation[ind];
+		this.activation = getFirstDayOfWeek();
+		this.expiry = getLastDayOfWeek();
+		this.remaining = timeDeltaToString(this.expiry.getTime() - Date.now());
+		this.rotation = steelPath(locale).rotation;
+		this.evergreens = steelPath(locale).evergreen;
+		this.incursions = {
+			id: `spi:${getStartOfDay().getTime()}`,
+			activation: getStartOfDay(),
+			expiry: getEndOfDay()
+		};
+	}
+};
+
+//#endregion
+export { SteelPathOfferings };

package/dist/SteelPathOffering-OHNTCFo5.d.ts

@@ -0,0 +1,38 @@
+import { Locale } from "warframe-worldstate-data";
+import { SteelPathOffering } from "warframe-worldstate-data/types";
+
+//#region lib/models/SteelPathOffering.d.ts
+
+/**
+ *  General data pertaining to incursions
+ */
+interface Incursion {
+  /**
+   * Identifier for steel path incursion based on start of day.
+   */
+  id: string;
+  /**
+   * when the current incursions became active
+   */
+  activation: Date;
+  /**
+   * when the current incursions become inactive
+   */
+  expiry: Date;
+}
+declare class SteelPathOfferings {
+  currentReward: SteelPathOffering;
+  activation: Date;
+  expiry: Date;
+  remaining: string;
+  rotation: SteelPathOffering[];
+  evergreens: SteelPathOffering[];
+  incursions: Incursion;
+  constructor({
+    locale
+  }: {
+    locale: Locale;
+  });
+}
+//#endregion
+export { Incursion, SteelPathOfferings };

package/dist/SyndicateJob-BK7OMLmv.js

@@ -0,0 +1,141 @@
+import { WorldstateObject } from "./WorldstateObject-BSTYuZwm.js";
+import { languageString } from "warframe-worldstate-data/utilities";
+
+//#region lib/models/SyndicateJob.ts
+const apiBase = process.env.API_BASE_URL || "https://api.warframestat.us";
+const bountyRewardRegex = /(?:Tier([ABCDE])|Narmer)Table([ABC])Rewards/i;
+const ghoulRewardRegex = /GhoulBountyTable([AB])Rewards/i;
+/**
+* Determine the level string for the bounty
+*/
+const getLevelString = (job) => `${job.minEnemyLevel} - ${job.maxEnemyLevel}`;
+const determineLocation = (i18n, raw, isVault) => {
+	const last = String(i18n).split("/").slice(-1)[0];
+	const bountyMatches = last.match(bountyRewardRegex);
+	const ghoulMatches = last.match(ghoulRewardRegex);
+	const isBounty = bountyMatches?.length;
+	const isGhoul = ghoulMatches?.length;
+	const isCetus = /eidolonjob/i.test(i18n);
+	const isVallis = /venusjob/i.test(i18n);
+	const isDeimos = /deimosmissionrewards/i.test(i18n);
+	const rotation = isBounty ? bountyMatches[2] : "";
+	const levelString = getLevelString(raw);
+	let location;
+	let levelClause;
+	if (isCetus) {
+		location = "Earth/Cetus ";
+		if (isGhoul) levelClause = `(Level ${levelString} Ghoul Bounty)`;
+		else levelClause = `(Level ${levelString} Cetus Bounty)`;
+	}
+	if (isVallis) {
+		location = "Venus/Orb Vallis ";
+		levelClause = `(Level ${levelString} Orb Vallis Bounty)`;
+	}
+	if (isDeimos) {
+		location = "Deimos/Cambion Drift ";
+		const variant = isVault ? "Isolation Vault" : "Cambion Drift Bounty";
+		levelClause = `(Level ${levelString} ${variant})`;
+	}
+	const locationWRot = `${location}${levelClause}, Rot ${rotation.length ? rotation : "A"}`;
+	return {
+		location,
+		locationWRot
+	};
+};
+const getBountyRewards = async (i18n, raw, isVault) => {
+	let location;
+	let locationWRot;
+	if (i18n.endsWith("PlagueStarTableRewards")) {
+		location = "plague star";
+		locationWRot = "Earth/Cetus (Level 15 - 25 Plague Star), Rot A";
+	}
+	if (!location || !locationWRot) ({location, locationWRot} = determineLocation(i18n, raw, isVault));
+	const url = `${apiBase}/drops/search/${encodeURIComponent(location)}?grouped_by=location`;
+	const reply = await fetch(url).then((res) => res.json()).catch(() => {});
+	const pool = reply?.[locationWRot];
+	if (!pool) return ["Pattern Mismatch. Results inaccurate."];
+	const results = pool.rewards;
+	if (results) return Array.from(new Set(results.map((result) => result.item)));
+	return [];
+};
+const FIFTY_MINUTES = 3e6;
+/**
+* Represents a syndicate daily mission
+* @augments {WorldstateObject}
+*/
+var SyndicateJob = class SyndicateJob extends WorldstateObject {
+	/**
+	* Array of strings describing rewards
+	*/
+	rewardPool;
+	/**
+	* The type of job this is
+	*/
+	type;
+	/**
+	* Array of enemy levels
+	*/
+	enemyLevels;
+	/**
+	* Array of standing gains per stage of job
+	*/
+	standingStages;
+	/**
+	* Minimum mastery required to participate
+	*/
+	minMR;
+	/**
+	* Whether or not this is a Vault job.
+	* No indication for difference of normal vs arcana vaults.
+	*/
+	isVault;
+	/**
+	* Corresponding chamber. Nullable
+	*/
+	locationTag;
+	/**
+	* What time phase this bounty is bound to
+	*/
+	timeBound;
+	/**
+	* Generate a job with async data (reward pool)
+	* @param data   The syndicate mission data
+	* @param expiry The syndicate job expiration
+	* @param deps   The dependencies object
+	* @returns The created SyndicateJob object with rewardPool
+	*/
+	static async build(data, expiry, deps) {
+		const job = new SyndicateJob(data, expiry, deps);
+		job.rewardPool = await getBountyRewards(data.rewards, data, data.isVault);
+		return job;
+	}
+	/**
+	* Construct a job without async data (reward pool)
+	* @param data        The syndicate mission data
+	* @param expiry      The syndicate job expiration
+	* @param deps        The dependencies object
+	* @param deps.locale Locale to use for translations
+	*
+	* This DOES NOT populate the reward pool
+	*/
+	constructor(data, expiry, { locale } = { locale: "en" }) {
+		super({ _id: { $oid: data.JobCurrentVersion ? data.JobCurrentVersion.$oid : `${(data.jobType || "").split("/").slice(-1)[0]}${expiry.getTime()}` } });
+		this.rewardPool = [];
+		const chamber = ((data.locationTag || "").match(/[A-Z]+(?![a-z])|[A-Z]?[a-z]+|\d+/g) || []).join(" ");
+		this.type = data.isVault ? `Isolation Vault ${chamber}` : data.jobType ? languageString(data.jobType, locale) : void 0;
+		this.enemyLevels = [data.minEnemyLevel, data.maxEnemyLevel];
+		this.standingStages = data.xpAmounts;
+		this.minMR = data.masteryReq || 0;
+		this.isVault = data.isVault;
+		this.locationTag = data.locationTag;
+		this.expiry = expiry;
+		const jobType = data.jobType ?? "";
+		if (jobType.toLowerCase().includes("narmer")) if (jobType.toLowerCase().includes("eidolon")) {
+			this.timeBound = "day";
+			this.expiry = new Date(this.expiry.getTime() - FIFTY_MINUTES);
+		} else this.timeBound = "night";
+	}
+};
+
+//#endregion
+export { SyndicateJob };

package/dist/SyndicateJob-DOtXWjRF.d.ts

@@ -0,0 +1,76 @@
+import { Dependency } from "./Dependency-DkOHLql6.js";
+import { Identifier, WorldstateObject } from "./WorldstateObject-wfRTeGpm.js";
+
+//#region lib/models/SyndicateJob.d.ts
+interface RawSyndicateJob {
+  rewards: string;
+  isVault?: boolean;
+  JobCurrentVersion?: Identifier;
+  jobType?: string;
+  locationTag?: string;
+  minEnemyLevel: number;
+  maxEnemyLevel: number;
+  xpAmounts: number[];
+  masteryReq?: number;
+}
+/**
+ * Represents a syndicate daily mission
+ * @augments {WorldstateObject}
+ */
+declare class SyndicateJob extends WorldstateObject {
+  /**
+   * Array of strings describing rewards
+   */
+  rewardPool: string[];
+  /**
+   * The type of job this is
+   */
+  type?: string;
+  /**
+   * Array of enemy levels
+   */
+  enemyLevels: number[];
+  /**
+   * Array of standing gains per stage of job
+   */
+  standingStages: number[];
+  /**
+   * Minimum mastery required to participate
+   */
+  minMR: number;
+  /**
+   * Whether or not this is a Vault job.
+   * No indication for difference of normal vs arcana vaults.
+   */
+  isVault?: boolean;
+  /**
+   * Corresponding chamber. Nullable
+   */
+  locationTag?: string;
+  /**
+   * What time phase this bounty is bound to
+   */
+  timeBound: string | undefined;
+  /**
+   * Generate a job with async data (reward pool)
+   * @param data   The syndicate mission data
+   * @param expiry The syndicate job expiration
+   * @param deps   The dependencies object
+   * @returns The created SyndicateJob object with rewardPool
+   */
+  static build(data: RawSyndicateJob, expiry: Date, deps: Dependency): Promise<SyndicateJob>;
+  /**
+   * Construct a job without async data (reward pool)
+   * @param data        The syndicate mission data
+   * @param expiry      The syndicate job expiration
+   * @param deps        The dependencies object
+   * @param deps.locale Locale to use for translations
+   *
+   * This DOES NOT populate the reward pool
+   */
+  constructor(data: RawSyndicateJob, expiry: Date, {
+    locale
+  }?: Dependency);
+}
+//#endregion
+export { RawSyndicateJob, SyndicateJob };

package/dist/SyndicateMission-5PZIEM8P.js

@@ -0,0 +1,66 @@
+import { WorldstateObject } from "./WorldstateObject-BSTYuZwm.js";
+import { SyndicateJob } from "./SyndicateJob-BK7OMLmv.js";
+import { fromNow, node, syndicate, timeDeltaToString } from "warframe-worldstate-data/utilities";
+
+//#region lib/models/SyndicateMission.ts
+/**
+* Represents a syndicate daily mission
+* @augments {WorldstateObject}
+*/
+var SyndicateMission = class SyndicateMission extends WorldstateObject {
+	/**
+	* The syndicate that is offering the mission
+	* @type {string}
+	*/
+	syndicate;
+	/**
+	* The syndicate that is offering the mission
+	* @type {string}
+	*/
+	syndicateKey;
+	/**
+	* The nodes on which the missions are taking place
+	* @type {Array.<string>}
+	*/
+	nodes;
+	/**
+	* The jobs for this syndicate. Will normally be []
+	* @type {Array.<SyndicateJob>}
+	*/
+	jobs;
+	/**
+	* Build a new SyndicateMission with async operations & data
+	* @param   data        The syndicate mission data
+	* @param   deps        The dependencies object
+	* @param   deps.locale Locale to use for translations
+	* @returns SyndicateMission object w/ async resolution of jobs
+	*/
+	static async build(data, deps = { locale: "en" }) {
+		const syndicateMission = new SyndicateMission(data, deps);
+		if (data.Jobs?.length) syndicateMission.jobs = await Promise.all(data.Jobs.map((job) => SyndicateJob.build(job, syndicateMission.expiry, deps)));
+		else syndicateMission.jobs = [];
+		return syndicateMission;
+	}
+	/**
+	* @param data        The syndicate mission data
+	* @param deps        The dependencies object
+	* @param deps.locale Locale to use for translations
+	*/
+	constructor(data, { locale = "en" } = { locale: "en" }) {
+		super(data);
+		this.syndicate = syndicate(data.Tag, locale);
+		this.syndicateKey = syndicate(data.Tag, "en");
+		this.nodes = data.Nodes.map((n) => node(n, locale));
+		this.jobs = [];
+		this.id = `${this.expiry.getTime()}${data.Tag}`;
+	}
+	/**
+	* Time delta string from now to the expiry
+	*/
+	get eta() {
+		return timeDeltaToString(fromNow(this.expiry));
+	}
+};
+
+//#endregion
+export { SyndicateMission };

package/dist/SyndicateMission-DmGG5lGy.d.ts

@@ -0,0 +1,58 @@
+import { Dependency } from "./Dependency-DkOHLql6.js";
+import { BaseContentObject, WorldstateObject } from "./WorldstateObject-wfRTeGpm.js";
+import { RawSyndicateJob, SyndicateJob } from "./SyndicateJob-DOtXWjRF.js";
+
+//#region lib/models/SyndicateMission.d.ts
+interface RawSyndicateMission extends BaseContentObject {
+  Tag: string;
+  Nodes: string[];
+  Jobs: RawSyndicateJob[];
+}
+/**
+ * Represents a syndicate daily mission
+ * @augments {WorldstateObject}
+ */
+declare class SyndicateMission extends WorldstateObject {
+  /**
+   * The syndicate that is offering the mission
+   * @type {string}
+   */
+  syndicate: string;
+  /**
+   * The syndicate that is offering the mission
+   * @type {string}
+   */
+  syndicateKey: string;
+  /**
+   * The nodes on which the missions are taking place
+   * @type {Array.<string>}
+   */
+  nodes: string[];
+  /**
+   * The jobs for this syndicate. Will normally be []
+   * @type {Array.<SyndicateJob>}
+   */
+  jobs: SyndicateJob[];
+  /**
+   * Build a new SyndicateMission with async operations & data
+   * @param   data        The syndicate mission data
+   * @param   deps        The dependencies object
+   * @param   deps.locale Locale to use for translations
+   * @returns SyndicateMission object w/ async resolution of jobs
+   */
+  static build(data: RawSyndicateMission, deps?: Dependency): Promise<SyndicateMission>;
+  /**
+   * @param data        The syndicate mission data
+   * @param deps        The dependencies object
+   * @param deps.locale Locale to use for translations
+   */
+  constructor(data: RawSyndicateMission, {
+    locale
+  }?: Dependency);
+  /**
+   * Time delta string from now to the expiry
+   */
+  get eta(): string;
+}
+//#endregion
+export { RawSyndicateMission, SyndicateMission };

package/dist/Tmp-DkQq1arD.js

@@ -0,0 +1,21 @@
+import { Archimedea } from "./Archidemea-C0EMRUKc.js";
+import { Kinepage } from "./Kinepage-iWFwTZtr.js";
+import { SentientOutpost } from "./SentientOutpost-B2KZUJ7H.js";
+
+//#region lib/Tmp.ts
+var Tmp = class {
+	sentientOutposts;
+	kinepage;
+	deepArchimedea;
+	temporalArchimedea;
+	constructor(json, deps = { locale: "en" }) {
+		const tmp = JSON.parse(json);
+		this.sentientOutposts = new SentientOutpost(tmp.sfn, deps);
+		this.kinepage = new Kinepage(tmp.pgr, deps.locale);
+		if (tmp.lqo) this.deepArchimedea = new Archimedea(tmp.lqo, deps.locale);
+		if (tmp.hqo) this.temporalArchimedea = new Archimedea(tmp.hqo, deps.locale);
+	}
+};
+
+//#endregion
+export { Tmp };

package/dist/VallisCycle-BX8yyKx3.js

@@ -0,0 +1,76 @@
+import { WorldstateObject } from "./WorldstateObject-BSTYuZwm.js";
+import { fromNow, timeDeltaToString } from "warframe-worldstate-data/utilities";
+
+//#region lib/models/VallisCycle.ts
+const lStart = /* @__PURE__ */ new Date("November 10, 2018 08:13:48 UTC");
+const loopTime = 16e5;
+const warmTime = 4e5;
+const coldTime = loopTime - warmTime;
+/**
+* Get the current cycle state for Orb Vallis
+* @returns current cycle state
+*/
+function getCurrentCycle() {
+	const sinceLast = (Date.now() - lStart.getMilliseconds()) % loopTime;
+	const toNextFull = loopTime - sinceLast;
+	let state = "cold";
+	if (toNextFull > coldTime) state = "warm";
+	let toNextMinor;
+	if (toNextFull < coldTime) toNextMinor = toNextFull;
+	else toNextMinor = toNextFull - coldTime;
+	const milliAtNext = Date.now() + toNextMinor;
+	const milliAtPrev = Date.now() + toNextFull - (state === "warm" ? loopTime : coldTime);
+	const timeAtPrevious = new Date(milliAtPrev);
+	timeAtPrevious.setSeconds(0);
+	return {
+		state,
+		toNextMinor,
+		toNextFull,
+		timeAtNext: new Date(milliAtNext),
+		timeAtPrevious
+	};
+}
+/**
+* Represents the current Earth Day/Night Cycle
+* @augments {WorldstateObject}
+*/
+var VallisCycle = class extends WorldstateObject {
+	/**
+	* Whether or not this it's daytime
+	*/
+	isWarm;
+	/**
+	* Current cycle state. One of `warm`, `cold`
+	*/
+	state;
+	/**
+	* The current cetus cycle, for calculating the other fields
+	*/
+	#ec = getCurrentCycle();
+	constructor() {
+		super({ _id: { $oid: "vallisCycle0" } });
+		this.id = `vallisCycle${this.#ec.timeAtPrevious.getTime()}`;
+		this.activation = this.#ec.timeAtPrevious;
+		this.expiry = this.#ec.timeAtNext;
+		this.isWarm = this.#ec.state === "warm";
+		this.state = this.#ec.state;
+	}
+	/**
+	* Whether this event has expired
+	*/
+	get expired() {
+		return fromNow(this.expiry) < 0;
+	}
+	/**
+	* Time remaining string
+	*/
+	get timeLeft() {
+		return timeDeltaToString(this.#ec.toNextMinor);
+	}
+	get shortString() {
+		return `${this.timeLeft.replace(/\s\d*s/gi, "")} to ${this.isWarm ? "Cold" : "Warm"}`;
+	}
+};
+
+//#endregion
+export { VallisCycle };

package/dist/VallisCycle-BXcmzqqG.d.ts

@@ -0,0 +1,31 @@
+import { WorldstateObject } from "./WorldstateObject-wfRTeGpm.js";
+
+//#region lib/models/VallisCycle.d.ts
+
+/**
+ * Represents the current Earth Day/Night Cycle
+ * @augments {WorldstateObject}
+ */
+declare class VallisCycle extends WorldstateObject {
+  #private;
+  /**
+   * Whether or not this it's daytime
+   */
+  isWarm: boolean;
+  /**
+   * Current cycle state. One of `warm`, `cold`
+   */
+  state: string;
+  constructor();
+  /**
+   * Whether this event has expired
+   */
+  get expired(): boolean;
+  /**
+   * Time remaining string
+   */
+  get timeLeft(): string;
+  get shortString(): string;
+}
+//#endregion
+export { VallisCycle };