@wfcd/relics 2.0.28 → 2.0.29

package/dist/VersionManager-DkHKfTUL.cjs

@@ -0,0 +1,336 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", {
+	value,
+	configurable: true
+});
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+let node_fs_promises = require("node:fs/promises");
+node_fs_promises = __toESM(node_fs_promises);
+let node_path = require("node:path");
+node_path = __toESM(node_path);
+let node_fetch = require("node-fetch");
+node_fetch = __toESM(node_fetch);
+let node_console = require("node:console");
+node_console = __toESM(node_console);
+
+//#region src/Config.ts
+const Config = {
+	warframeRelicDropUrl: "https://drops.warframestat.us/data/relics.json",
+	warframeMarketItemUrl: "https://api.warframe.market/v2/items",
+	warframeItemsUrl: "https://api.warframestat.us/items/search/Relics?by=category",
+	warframeRelicDropInfoUrl: "https://drops.warframestat.us/data/info.json",
+	warframePatchlogsUrl: "https://raw.githubusercontent.com/WFCD/warframe-patchlogs/master/data/patchlogs.json"
+};
+
+//#endregion
+//#region src/Logger.ts
+var LogLevel = /* @__PURE__ */ function(LogLevel) {
+	LogLevel[LogLevel["FATAL"] = -1] = "FATAL";
+	LogLevel[LogLevel["ERROR"] = 0] = "ERROR";
+	LogLevel[LogLevel["LOG"] = 1] = "LOG";
+	LogLevel[LogLevel["DEBUG"] = 2] = "DEBUG";
+	return LogLevel;
+}(LogLevel || {});
+const fromString = (logLevelIsh) => {
+	switch (logLevelIsh === null || logLevelIsh === void 0 ? void 0 : logLevelIsh.toLowerCase()) {
+		case "fatal": return LogLevel.FATAL;
+		case "error":
+		case "bad": return LogLevel.ERROR;
+		case "info":
+		case "log": return LogLevel.LOG;
+		case "debug": return LogLevel.DEBUG;
+		default: return LogLevel.FATAL;
+	}
+};
+var Logger = class {
+	logLevel = fromString(process.env.LOG_LEVEL || "fatal");
+	log(message) {
+		if (this.logLevel >= LogLevel.LOG) node_console.log(message);
+	}
+	error(message) {
+		if (this.logLevel >= LogLevel.ERROR) node_console.error(message);
+	}
+	debug(message) {
+		if (this.logLevel === LogLevel.DEBUG) node_console.debug(message);
+	}
+	fatal(message) {
+		if (this.logLevel >= LogLevel.FATAL) {
+			node_console.error(`FATAL: ${message}`);
+			throw new Error(message);
+		}
+	}
+};
+var Logger_default = new Logger();
+
+//#endregion
+//#region src/Generator.ts
+var Generator = class {
+	relicsRaw;
+	wfcdItems;
+	wfmItems;
+	relics;
+	constructor() {
+		this.relics = [];
+	}
+	/**
+	* Main function to fetch and generate the relic data
+	* @returns {Promise<Array<TitaniaRelic>>} The Relics data array
+	*/
+	async generate() {
+		Logger_default.log("Starting Generation");
+		await this.fetchRawData();
+		this.filterWFCDRelics();
+		this.generateTitaniaRelics();
+		return this.relics;
+	}
+	/**
+	* Fetches all required data from WFCD and WFM.
+	*/
+	async fetchRawData() {
+		var _await$relicRequest$j;
+		const relicRequest = await (0, node_fetch.default)(Config.warframeRelicDropUrl);
+		if (!relicRequest.ok) {
+			Logger_default.error("Failed to fetch Warframe relics from WFCD!");
+			return;
+		}
+		this.relicsRaw = (_await$relicRequest$j = await relicRequest.json()) === null || _await$relicRequest$j === void 0 ? void 0 : _await$relicRequest$j.relics;
+		const wfmRequest = await (0, node_fetch.default)(Config.warframeMarketItemUrl);
+		if (!wfmRequest.ok) {
+			Logger_default.error("Failed to fetch items from WFM!");
+			return;
+		}
+		this.wfmItems = await wfmRequest.json();
+		const wfcdItemRequest = await (0, node_fetch.default)(Config.warframeItemsUrl);
+		if (!wfcdItemRequest.ok) {
+			Logger_default.error("Failed to fetch items from WFCD! ");
+			return;
+		}
+		this.wfcdItems = await wfcdItemRequest.json();
+	}
+	/**
+	* Generates the relic data
+	*  uses WFCD/warframe-drop-data to check what relics exist,
+	*  and adds information from WFCD/warframe-items and WFM
+	*/
+	generateTitaniaRelics() {
+		if (typeof this.relicsRaw === "undefined" || typeof this.wfmItems === "undefined") {
+			Logger_default.log("Failed to load relics/item data");
+			return;
+		}
+		const { length } = this.relicsRaw;
+		for (let i = 0; i < length; i += 1) {
+			const rawRelic = this.relicsRaw[i];
+			Logger_default.debug(`[${i + 1}/${length}] ${rawRelic.tier} ${rawRelic.relicName}`);
+			const relic = this.generateTitaniaRelic(rawRelic);
+			this.relics.push(relic);
+		}
+		Logger_default.debug(`Finished parsing ${this.relics.length} relics`);
+	}
+	/**
+	* Writes the fully generated data to disk.
+	* @param {string} dataDir Directory to store the relic data in. Default: ../data/
+	* @param {string} fileName Filename base ex: "Relics" becomes "Relics.json" and "Relics.min.json". Default: "Relics"
+	* @param {boolean} generateMin True if a minified json should be generated too. Default: true
+	*/
+	async writeData(dataDir, fileName, generateMin = true) {
+		const DataDir = dataDir ?? node_path.default.join(__dirname, "..", "data");
+		const RelicPath = fileName ? node_path.default.join(DataDir, `${fileName}.json`) : node_path.default.join(DataDir, "Relics.json");
+		await node_fs_promises.default.writeFile(RelicPath, JSON.stringify(this.relics, void 0, 4));
+		if (generateMin) {
+			const RelicMinPath = fileName ? node_path.default.join(DataDir, `${fileName}.min.json`) : node_path.default.join(DataDir, "Relics.min.json");
+			await node_fs_promises.default.writeFile(RelicMinPath, JSON.stringify(this.relics));
+		}
+	}
+	/**
+	* Generates a single relic from all available data
+	* @param {WFCDRelic} rawRelic relic to pull Titania data from
+	* @returns {TitaniaRelicReward}
+	*/
+	generateTitaniaRelic(rawRelic) {
+		var _this$wfcdItems2;
+		var _this$wfmItems2;
+		const name = `${rawRelic.tier} ${rawRelic.relicName}`;
+		const rewards = rawRelic.rewards.map((rawReward) => {
+			var _this$wfmItems;
+			var _this$wfcdItems;
+			const { chance } = rawReward;
+			const { rarity } = rawReward;
+			const wfmInfo = (_this$wfmItems = this.wfmItems) === null || _this$wfmItems === void 0 ? void 0 : _this$wfmItems.data.find((x) => {
+				return x.i18n.en.name.toLowerCase() === rawReward.itemName.toLowerCase();
+			});
+			const isSpecial = [
+				"Forma",
+				"Kuva",
+				"Exilus",
+				"Riven"
+			].find((x) => rawReward.itemName.toLowerCase().includes(x.toLowerCase()));
+			if (!(wfmInfo || isSpecial)) Logger_default.debug(`Failed to find wfm item for ${rawReward.itemName}`);
+			const item = {
+				name: rawReward.itemName,
+				uniqueName: ((_this$wfcdItems = this.wfcdItems) === null || _this$wfcdItems === void 0 || (_this$wfcdItems = _this$wfcdItems.find((x) => x.name.toLowerCase() === `${name.trim()} Intact`.toLowerCase())) === null || _this$wfcdItems === void 0 ? void 0 : _this$wfcdItems.uniqueName) || "",
+				warframeMarket: void 0
+			};
+			if (wfmInfo) item.warframeMarket = {
+				id: wfmInfo.id,
+				urlName: wfmInfo.slug
+			};
+			return {
+				rarity,
+				chance,
+				item
+			};
+		});
+		let drops = [];
+		const wfcdItem = (_this$wfcdItems2 = this.wfcdItems) === null || _this$wfcdItems2 === void 0 ? void 0 : _this$wfcdItems2.find((x) => x.name.toLowerCase() === `${name.trim()} Intact`.toLowerCase());
+		if (!wfcdItem) Logger_default.error(`Failed to get WFCD item for relic: ${name}`);
+		if (wfcdItem && wfcdItem.drops) drops = wfcdItem.drops.map((rawDrop) => {
+			return {
+				rarity: rawDrop.rarity,
+				chance: rawDrop.chance,
+				location: rawDrop.location
+			};
+		});
+		const wfm = (_this$wfmItems2 = this.wfmItems) === null || _this$wfmItems2 === void 0 ? void 0 : _this$wfmItems2.data.find((x) => {
+			return x.i18n.en.name.toLowerCase() === `${name.trim()} Relic`.toLowerCase();
+		});
+		if (!wfm) Logger_default.error(`Failed to get relic item from wfm: ${name}`);
+		return {
+			name,
+			rewards,
+			locations: drops,
+			uniqueName: (wfcdItem === null || wfcdItem === void 0 ? void 0 : wfcdItem.uniqueName) || "",
+			vaultInfo: { vaulted: drops.length === 0 },
+			...(wfm === null || wfm === void 0 ? void 0 : wfm.id) && (wfm === null || wfm === void 0 ? void 0 : wfm.slug) && { warframeMarket: {
+				id: wfm === null || wfm === void 0 ? void 0 : wfm.id,
+				urlName: wfm === null || wfm === void 0 ? void 0 : wfm.slug
+			} }
+		};
+	}
+	/**
+	* Filters WFCD's relic data to only include Intact variants, since we just need the base.
+	*/
+	filterWFCDRelics() {
+		var _this$relicsRaw;
+		var _this$relicsRaw2;
+		var _this$relicsRaw3;
+		const before = ((_this$relicsRaw = this.relicsRaw) === null || _this$relicsRaw === void 0 ? void 0 : _this$relicsRaw.length) || 0;
+		this.relicsRaw = (_this$relicsRaw2 = this.relicsRaw) === null || _this$relicsRaw2 === void 0 ? void 0 : _this$relicsRaw2.filter((x) => x.state === "Intact");
+		Logger_default.log(`Filtered relics to intact variants. Before: ${before} After: ${((_this$relicsRaw3 = this.relicsRaw) === null || _this$relicsRaw3 === void 0 ? void 0 : _this$relicsRaw3.length) || 0}`);
+	}
+};
+
+//#endregion
+//#region src/VersionManager.ts
+var VersionManager = class {
+	versionPath;
+	versionRawPath;
+	hashPath;
+	/**
+	* Creates a new VersionManager instance.
+	* @param {string} dataDir Folder to write version information to.
+	* @constructor
+	*/
+	constructor(dataDir) {
+		const DataDir = dataDir ?? node_path.default.join(__dirname, "..", "data");
+		this.versionPath = node_path.default.join(DataDir, "version.json");
+		this.versionRawPath = node_path.default.join(DataDir, "version.txt");
+		this.hashPath = node_path.default.join(DataDir, "hash.json");
+	}
+	/**
+	* Checks if the current data needs an update
+	*/
+	async updateNeeded() {
+		const infoReq = await (0, node_fetch.default)(Config.warframeRelicDropInfoUrl);
+		if (!infoReq.ok) Logger_default.fatal("Failed to fetch version info!");
+		const info = await infoReq.json();
+		try {
+			await node_fs_promises.default.access(this.hashPath);
+			return JSON.parse(await node_fs_promises.default.readFile(this.hashPath, "utf-8")).hash !== info.hash;
+		} catch (ex) {
+			return true;
+		}
+	}
+	/**
+	* Writes both game and drop version metadata
+	* @param {number} timestamp Timestamp the build was started at
+	*/
+	async writeVersion(timestamp) {
+		const patchLogsReq = await (0, node_fetch.default)(Config.warframePatchlogsUrl);
+		if (!patchLogsReq.ok) {
+			Logger_default.error("Failed to fetch patchlogs");
+			return;
+		}
+		const patchlogs = await patchLogsReq.json();
+		const version = patchlogs[0].name.replace(/ \+ /g, "--").replace(/[^0-9\-.]/g, "").trim();
+		const hashReq = await (0, node_fetch.default)(Config.warframeRelicDropInfoUrl);
+		if (!hashReq.ok) {
+			Logger_default.error("Failed to fetch hashInfo");
+			return;
+		}
+		const hashInfo = await hashReq.json();
+		const versionInfo = {
+			version,
+			title: patchlogs[0].name
+		};
+		const hashFile = {
+			hash: hashInfo.hash,
+			deUpdated: hashInfo.modified,
+			timestamp
+		};
+		await node_fs_promises.default.writeFile(this.hashPath, JSON.stringify(hashFile, void 0, 2), "utf-8");
+		await node_fs_promises.default.writeFile(this.versionPath, JSON.stringify(versionInfo, void 0, 2), "utf-8");
+		await node_fs_promises.default.writeFile(this.versionRawPath, version, "utf-8");
+		Logger_default.debug("Finished writing version info");
+	}
+};
+
+//#endregion
+Object.defineProperty(exports, 'Generator', {
+  enumerable: true,
+  get: function () {
+    return Generator;
+  }
+});
+Object.defineProperty(exports, 'Logger_default', {
+  enumerable: true,
+  get: function () {
+    return Logger_default;
+  }
+});
+Object.defineProperty(exports, 'VersionManager', {
+  enumerable: true,
+  get: function () {
+    return VersionManager;
+  }
+});
+Object.defineProperty(exports, '__name', {
+  enumerable: true,
+  get: function () {
+    return __name;
+  }
+});

package/dist/chunk-Dco9itRc.mjs

@@ -0,0 +1,9 @@
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", {
+	value,
+	configurable: true
+});
+
+//#endregion
+export { __name as t };

package/dist/index.cjs

@@ -0,0 +1,5 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_VersionManager = require('./VersionManager-DkHKfTUL.cjs');
+
+exports.Generator = require_VersionManager.Generator;
+exports.VersionManager = require_VersionManager.VersionManager;

package/dist/index.d.cts

@@ -0,0 +1,248 @@
+//#endregion
+//#region src/Types.d.ts
+interface WarframeMarketRoot {
+  data: Array<WarframeMarketItem>;
+}
+interface WarframeMarketItem {
+  /**
+   * WFM Item ID
+   */
+  id: string;
+  /**
+   * Url name for querying WFM
+   */
+  slug: string;
+  /**
+   * WFM language object
+   */
+  i18n: {
+    /**
+     * English language object
+     */
+    en: {
+      /**
+       * Item Name
+       */
+      name: string;
+      /**
+       * Thumbnail URL relative to wfm api base
+       */
+      thumb: string;
+    };
+  };
+}
+interface WFCDRelic {
+  /**
+   * Relic Tier (Axi, Neo, etc.)
+   */
+  tier: string;
+  /**
+   * Relic Name (A1, A10, etc.)
+   */
+  relicName: string;
+  /**
+   * Relic Refinement state
+   */
+  state: 'Intact' | 'Exceptional' | 'Flawless' | 'Radiant';
+  /**
+   * Relic Rewards
+   */
+  rewards: Array<WFCDRelicReward>;
+  /**
+   * Internal WFCD id
+   */
+  _id: string;
+}
+interface WFCDRelicReward {
+  /**
+   * Dropped Item name
+   */
+  itemName: string;
+  /**
+   * Dropchance Rarity (Uncommon/Rare ?)
+   */
+  rarity: 'Uncommon' | 'Rare';
+  /**
+   * Actual Dropchance in %
+   */
+  chance: number;
+  /**
+   * Internal ID
+   */
+  _id: string;
+}
+interface WFCDItem {
+  /**
+   * Item Name
+   */
+  name: string;
+  /** Unique identifying name */
+  uniqueName: string;
+  /**
+   * Item Drop Location
+   */
+  drops?: Array<WFCDItemDropLocation>;
+}
+interface WFCDItemDropLocation {
+  /**
+   * Dropchance in %
+   */
+  chance: number;
+  /**
+   * Mission location
+   */
+  location: string;
+  /**
+   * Drop rarity
+   */
+  rarity: string;
+  /**
+   * Relic Type
+   */
+  type: string;
+}
+interface TitaniaRelic {
+  /**
+   * Relic Combined Name (Ex: Axi A1)
+   */
+  name: string;
+  /**
+   * Relic Rewards when opened
+   */
+  rewards: Array<TitaniaRelicReward>;
+  /**
+   * Drop Locations for the relics
+   */
+  locations: Array<TitaniaRelicLocation>;
+  /**
+   * Warframe Market Information
+   *  undefined for untradable
+   */
+  warframeMarket?: TitaniaWFMInfo;
+  /**
+   * Relic Vault Information
+   */
+  vaultInfo: TitaniaRelicVaultedInfo;
+  /** unique name for corresponding warframe-items Item */
+  uniqueName: string;
+}
+interface TitaniaRelicReward {
+  /**
+   * Relic Rarity (Uncommon,Rare ?)
+   */
+  rarity: 'Uncommon' | 'Rare';
+  /**
+   * Reward Drop Chance in %
+   */
+  chance: number;
+  /**
+   * Item Information
+   */
+  item: TitaniaRelicRewardItem;
+}
+interface TitaniaRelicRewardItem {
+  /**
+   * Item Name
+   */
+  name: string;
+  /** unique name for corresponding warframe-items Item */
+  uniqueName: string;
+  /**
+   * WarframeMarket Info
+   */
+  warframeMarket?: TitaniaWFMInfo;
+}
+type Rarity = 'Uncommon' | 'Rare' | 'Legendary' | 'Common';
+interface TitaniaRelicLocation {
+  /** Location Info $planet-$node (Ex: Eris - Phalan) */
+  location: string;
+  /**
+   * Rarity (Uncommon, Rare ?)
+   */
+  rarity: Rarity;
+  /**
+   * Dropchance in %
+   */
+  chance: number;
+}
+interface TitaniaWFMInfo {
+  /**
+   * Warframe Market ID
+   */
+  id: string;
+  /**
+   * Warframe market URL parameter
+   */
+  urlName: string;
+}
+interface TitaniaRelicVaultedInfo {
+  /**
+   * If the relic is vaulted
+   */
+  vaulted: boolean;
+}
+//#endregion
+//#region src/Generator.d.ts
+declare class Generator {
+  relicsRaw: Array<WFCDRelic> | undefined;
+  wfcdItems: Array<WFCDItem> | undefined;
+  wfmItems: WarframeMarketRoot | undefined;
+  relics: Array<TitaniaRelic>;
+  constructor();
+  /**
+   * Main function to fetch and generate the relic data
+   * @returns {Promise<Array<TitaniaRelic>>} The Relics data array
+   */
+  generate(): Promise<Array<TitaniaRelic>>;
+  /**
+   * Fetches all required data from WFCD and WFM.
+   */
+  fetchRawData(): Promise<void>;
+  /**
+   * Generates the relic data
+   *  uses WFCD/warframe-drop-data to check what relics exist,
+   *  and adds information from WFCD/warframe-items and WFM
+   */
+  generateTitaniaRelics(): void;
+  /**
+   * Writes the fully generated data to disk.
+   * @param {string} dataDir Directory to store the relic data in. Default: ../data/
+   * @param {string} fileName Filename base ex: "Relics" becomes "Relics.json" and "Relics.min.json". Default: "Relics"
+   * @param {boolean} generateMin True if a minified json should be generated too. Default: true
+   */
+  writeData(dataDir?: string, fileName?: string, generateMin?: boolean): Promise<void>;
+  /**
+   * Generates a single relic from all available data
+   * @param {WFCDRelic} rawRelic relic to pull Titania data from
+   * @returns {TitaniaRelicReward}
+   */
+  private generateTitaniaRelic;
+  /**
+   * Filters WFCD's relic data to only include Intact variants, since we just need the base.
+   */
+  private filterWFCDRelics;
+}
+//#endregion
+//#region src/VersionManager.d.ts
+declare class VersionManager {
+  versionPath: string;
+  versionRawPath: string;
+  hashPath: string;
+  /**
+   * Creates a new VersionManager instance.
+   * @param {string} dataDir Folder to write version information to.
+   * @constructor
+   */
+  constructor(dataDir?: string);
+  /**
+   * Checks if the current data needs an update
+   */
+  updateNeeded(): Promise<boolean>;
+  /**
+   * Writes both game and drop version metadata
+   * @param {number} timestamp Timestamp the build was started at
+   */
+  writeVersion(timestamp: number): Promise<void>;
+}
+//#endregion
+export { Generator, Rarity, TitaniaRelic, TitaniaRelicLocation, TitaniaRelicReward, TitaniaRelicRewardItem, TitaniaRelicVaultedInfo, TitaniaWFMInfo, VersionManager, WFCDItem, WFCDItemDropLocation, WFCDRelic, WFCDRelicReward, WarframeMarketItem, WarframeMarketRoot };