items data

package-lock.json

@@ -7,6 +7,7 @@
     "": {
       "name": "wf-emulator",
       "version": "0.1.0",
+      "hasInstallScript": true,
       "license": "GNU",
       "dependencies": {
         "dotenv": "^16.1.3",

package.json

@@ -8,7 +8,8 @@
     "dev": "ts-node-dev --openssl-legacy-provider -r tsconfig-paths/register src/index.ts",
     "build": "webpack",
     "lint": "eslint --ext .ts .",
-    "prettier": "prettier --write ."
+    "prettier": "prettier --write .",
+    "postinstall": "node static/json/scripts/update-items.js"
   },
   "license": "GNU",
   "dependencies": {

src/helpers/customHelpers/addItemHelpers.ts

@@ -1,5 +1,5 @@
 import { isString, parseString } from "@/src/helpers/general";
-import { items } from "@/static/data/items";
+import allUniqNames from "@/static/json/all-uniq-names.json";
 
 export enum ItemType {
     Powersuit = "Powersuit",
@@ -24,8 +24,7 @@ interface IAddItemRequest {
     accountId: string;
 }
 export const isInternalName = (internalName: string): boolean => {
-    const item = items.find(i => i.uniqueName === internalName);
+    return allUniqNames.includes(internalName);
-    return Boolean(item);
 };
 
 const parseInternalName = (internalName: unknown): string => {

src/helpers/purchaseHelpers.ts

@@ -1,7 +1,7 @@
 import { parseBoolean, parseNumber, parseString } from "@/src/helpers/general";
 import { WeaponTypeInternal } from "@/src/services/inventoryService";
 import { IPurchaseRequest } from "@/src/types/purchaseTypes";
-import { weapons } from "@/static/data/items";
+import weaponCategories from "@/static/json/weapon-categories.json";
 
 const toPurchaseRequest = (purchaseRequest: unknown): IPurchaseRequest => {
     if (!purchaseRequest || typeof purchaseRequest !== "object") {
@@ -41,13 +41,7 @@ const toPurchaseRequest = (purchaseRequest: unknown): IPurchaseRequest => {
 };
 
 const getWeaponType = (weaponName: string) => {
-    const weaponInfo = weapons.find(i => i.uniqueName === weaponName);
+    const weaponType = (weaponCategories as ImportAssertions)[weaponName] as WeaponTypeInternal;
-
-    if (!weaponInfo) {
-        throw new Error(`unknown weapon ${weaponName}`);
-    }
-
-    const weaponType = weaponInfo.productCategory as WeaponTypeInternal;
 
     if (!weaponType) {
         throw new Error(`unknown weapon category for item ${weaponName}`);

src/services/missionInventoryUpdateService .ts

@@ -1,7 +1,12 @@
 import { IMissionRewardResponse, IReward, IInventoryFieldType, inventoryFields } from "@/src/types/missionTypes";
 
 import missionsDropTable from "@/static/json/missions-drop-table.json";
-import { modNames, relicNames, miscNames, resourceNames, gearNames, blueprintNames } from "@/static/data/items";
+import modNames from "@/static/json/mod-names.json";
+import relicNames from "@/static/json/relic-names.json";
+import miscNames from "@/static/json/misc-names.json";
+import resourceNames from "@/static/json/resource-names.json";
+import gearNames from "@/static/json/gear-names.json";
+import blueprintNames from "@/static/json/blueprint-names.json";
 import { IMissionInventoryUpdateRequest } from "../types/requestTypes";
 
 // need reverse engineer rewardSeed, otherwise ingame displayed rotation reward will be different than added to db or displayed on mission end
@@ -153,16 +158,16 @@ const itemCheck = (
     name: string
 ) => {
     const rewardCheck = {
-        RawUpgrades: modNames[name],
+        RawUpgrades: (modNames as ImportAssertions)[name],
-        Consumables: gearNames[name],
+        Consumables: (gearNames as ImportAssertions)[name],
         MiscItems:
-            miscNames[name] ||
+            (miscNames as ImportAssertions)[name] ||
-            miscNames[name.replace(/\d+X\s*/, "")] ||
+            (miscNames as ImportAssertions)[name.replace(/\d+X\s*/, "")] ||
-            resourceNames[name] ||
+            (resourceNames as ImportAssertions)[name] ||
-            resourceNames[name.replace(/\d+X\s*/, "")] ||
+            (resourceNames as ImportAssertions)[name.replace(/\d+X\s*/, "")] ||
-            relicNames[name.replace("Relic", "Intact")] ||
+            (relicNames as ImportAssertions)[name.replace("Relic", "Intact")] ||
-            relicNames[name.replace("Relic (Radiant)", "Radiant")],
+            (relicNames as ImportAssertions)[name.replace("Relic (Radiant)", "Radiant")],
-        Recipes: blueprintNames[name]
+        Recipes: (blueprintNames as ImportAssertions)[name]
     };
     for (const key of Object.keys(rewardCheck) as IInventoryFieldType[]) {
         if (rewardCheck[key]) {
@@ -223,19 +228,19 @@ const _missionRewardsCheckAllNamings = () => {
         });
     });
     tempRewards = tempRewards
-        .filter(reward => !modNames[reward.name])
+        .filter(reward => !(modNames as ImportAssertions)[reward.name])
-        .filter(reward => !miscNames[reward.name])
+        .filter(reward => !(miscNames as ImportAssertions)[reward.name])
-        .filter(reward => !miscNames[reward.name.replace(/\d+X\s*/, "")])
+        .filter(reward => !(miscNames as ImportAssertions)[reward.name.replace(/\d+X\s*/, "")])
-        .filter(reward => !resourceNames[reward.name])
+        .filter(reward => !(resourceNames as ImportAssertions)[reward.name])
-        .filter(reward => !resourceNames[reward.name.replace(/\d+X\s*/, "")])
+        .filter(reward => !(resourceNames as ImportAssertions)[reward.name.replace(/\d+X\s*/, "")])
-        .filter(reward => !gearNames[reward.name])
+        .filter(reward => !(gearNames as ImportAssertions)[reward.name])
         .filter(reward => {
             return (
-                !relicNames[reward.name.replace("Relic", "Intact")] &&
+                !(relicNames as ImportAssertions)[reward.name.replace("Relic", "Intact")] &&
-                !relicNames[reward.name.replace("Relic (Radiant)", "Radiant")]
+                !(relicNames as ImportAssertions)[reward.name.replace("Relic (Radiant)", "Radiant")]
             );
         })
-        .filter(reward => !blueprintNames[reward.name])
+        .filter(reward => !(blueprintNames as ImportAssertions)[reward.name])
         .filter(reward => !reward.name.includes(" Endo"))
         .filter(reward => !reward.name.includes(" Credits Cache") && !reward.name.includes("Return: "));
     console.log(tempRewards);

static/data/items.ts

@@ -1,60 +0,0 @@
-import Items, { Category, Item, Warframe, Weapon } from "warframe-items";
-
-type MinWeapon = Omit<Weapon, "patchlogs">;
-type MinItem = Omit<Item, "patchlogs">;
-
-export const weapons: MinWeapon[] = (new Items({ category: ["Primary", "Secondary", "Melee"] }) as Weapon[]).map(
-    item => {
-        const next = { ...item };
-        delete next.patchlogs;
-        return next;
-    }
-);
-
-export const items: MinItem[] = new Items({ category: ["All"] }).map(item => {
-    const next = { ...item };
-    delete next.patchlogs;
-    return next;
-});
-
-const getNamesObj = (category: Category) =>
-    new Items({ category: [category] }).reduce((acc, item) => {
-        acc[item.name!.replace("'S", "'s")] = item.uniqueName!;
-        return acc;
-    }, {} as ImportAssertions);
-
-export const modNames = getNamesObj("Mods");
-export const resourceNames = getNamesObj("Resources");
-export const miscNames = getNamesObj("Misc");
-export const relicNames = getNamesObj("Relics");
-export const skinNames = getNamesObj("Skins");
-export const arcaneNames = getNamesObj("Arcanes");
-export const gearNames = getNamesObj("Gear");
-
-export const craftNames: ImportAssertions = Object.fromEntries(
-    (
-        new Items({
-            category: [
-                "Warframes",
-                "Gear",
-                "Melee",
-                "Primary",
-                "Secondary",
-                "Sentinels",
-                "Misc",
-                "Arch-Gun",
-                "Arch-Melee"
-            ]
-        }) as Warframe[]
-    )
-        .flatMap(item => item.components || [])
-        .filter(item => item.drops && item.drops[0])
-        .map(item => [item.drops![0].type, item.uniqueName])
-);
-craftNames["Forma Blueprint"] = "/Lotus/Types/Recipes/Components/FormaBlueprint";
-
-export const blueprintNames: ImportAssertions = Object.fromEntries(
-    Object.keys(craftNames)
-        .filter(name => name.includes("Blueprint"))
-        .map(name => [name, craftNames[name]])
-);

static/json/scripts/update-items.js

@@ -0,0 +1,53 @@
+/* eslint-disable */
+const Items = require("warframe-items");
+const fs = require("fs");
+
+const weaponCategories = new Items({ category: ["Primary", "Secondary", "Melee"] }).reduce((acc, item) => {
+    acc[item.name] = item.productCategory;
+    return acc;
+}, {});
+
+const allItemTypes = new Items({ category: ["All"] }).map(item => item.uniqueName);
+
+const getNamesObj = category =>
+    new Items({ category: [category] }).reduce((acc, item) => {
+        acc[item.name.replace("'S", "'s")] = item.uniqueName;
+        return acc;
+    }, {});
+
+const modNames = getNamesObj("Mods");
+const resourceNames = getNamesObj("Resources");
+const miscNames = getNamesObj("Misc");
+const relicNames = getNamesObj("Relics");
+const skinNames = getNamesObj("Skins");
+const arcaneNames = getNamesObj("Arcanes");
+const gearNames = getNamesObj("Gear");
+
+const craftNames = Object.fromEntries(
+    new Items({
+        category: ["Warframes", "Gear", "Melee", "Primary", "Secondary", "Sentinels", "Misc", "Arch-Gun", "Arch-Melee"]
+    })
+        .flatMap(item => item.components || [])
+        .filter(item => item.drops && item.drops[0])
+        .map(item => [item.drops[0].type, item.uniqueName])
+);
+craftNames["Forma Blueprint"] = "/Lotus/Types/Recipes/Components/FormaBlueprint";
+
+const blueprintNames = Object.fromEntries(
+    Object.keys(craftNames)
+        .filter(name => name.includes("Blueprint"))
+        .map(name => [name, craftNames[name]])
+);
+
+const jsonDir = "static/json";
+
+fs.writeFileSync(`${jsonDir}/weapon-categories.json`, JSON.stringify(weaponCategories));
+fs.writeFileSync(`${jsonDir}/all-uniq-names.json`, JSON.stringify(allItemTypes));
+fs.writeFileSync(`${jsonDir}/mod-names.json`, JSON.stringify(modNames));
+fs.writeFileSync(`${jsonDir}/resource-names.json`, JSON.stringify(resourceNames));
+fs.writeFileSync(`${jsonDir}/misc-names.json`, JSON.stringify(miscNames));
+fs.writeFileSync(`${jsonDir}/relic-names.json`, JSON.stringify(relicNames));
+fs.writeFileSync(`${jsonDir}/skin-names.json`, JSON.stringify(skinNames));
+fs.writeFileSync(`${jsonDir}/arcane-names.json`, JSON.stringify(arcaneNames));
+fs.writeFileSync(`${jsonDir}/gear-names.json`, JSON.stringify(gearNames));
+fs.writeFileSync(`${jsonDir}/blueprint-names.json`, JSON.stringify(blueprintNames));

webpack.config.js

@@ -1,3 +1,4 @@
+/* eslint-disable */
 const resolve = require("path").resolve;
 const webpack = require("webpack");
 const TsconfigPathsPlugin = require("tsconfig-paths-webpack-plugin");
@@ -17,10 +18,7 @@ module.exports = {
             ejs: "ejs"
         }),
         new CopyPlugin({
-            patterns: [
+            patterns: [{ from: "static/certs/", to: "certs/" }]
-                { from: "static/certs/", to: "certs/" },
-                { from: "node_modules/warframe-items/data/json/", to: "data/json/" }
-            ]
         })
     ],
     module: {
@@ -42,11 +40,7 @@ module.exports = {
         ]
     },
     resolve: {
-        plugins: [
+        plugins: [new TsconfigPathsPlugin()],
-            new TsconfigPathsPlugin({
-                /* options: see below */
-            })
-        ],
         fallback: {
             "mongodb-client-encryption": false,
             aws4: false,
@@ -55,10 +49,7 @@ module.exports = {
             "@mongodb-js/zstd": false,
             kerberos: false
         },
-        extensions: [".tsx", ".ts", ".js"],
+        extensions: [".tsx", ".ts", ".js"]
-        alias: {
-            "static/certs/*": resolve(__dirname, "certs") // Assuming 'certs' is in the root directory
-        }
     },
     entry: ["./src/index.ts"],
     output: {