@wfcd/profile-parser 1.4.1 → 2.0.0

package/src/Profile.ts

@@ -0,0 +1,308 @@
+import { parseDate, WorldStateDate } from 'warframe-worldstate-data/utilities';
+
+import ChallengeProgress, { type RawChallengeProgress } from './ChallengeProgress';
+import Intrinsics, { type RawIntrinsics } from './Intrinsics';
+import LoadOutInventory, { type RawLoadOut } from './LoadOutInventory';
+import Mission, { type RawMission } from './Mission';
+import OperatorLoadOuts, { type RawOperatorLoadOuts } from './OperatorLoadOuts';
+import Syndicate, { type RawAffiliation } from './Syndicate';
+import LoadOutPreset, { type RawLoadOutPreset } from './LoadOutPreset';
+import type { RawDate, RawId } from './Utils';
+import { Locale } from 'warframe-worldstate-data';
+
+export interface RawProfile {
+  AccountId: { $oid: string };
+  DisplayName: string;
+  PlatformNames?: string[];
+  PlayerLevel: number;
+  LoadOutPreset: RawLoadOutPreset;
+  LoadOutInventory: RawLoadOut;
+  PlayerSkills: RawIntrinsics;
+  ChallengeProgress: RawChallengeProgress[];
+  GuildId: RawId;
+  GuildName: string;
+  GuildTier: number;
+  GuildXp: number;
+  GuildClass: number;
+  GuildEmblem: boolean;
+  AllianceId?: RawId;
+  DeathMarks: string[];
+  Harvestable: boolean;
+  DeathSquadable: boolean;
+  Created: RawDate;
+  MigratedToConsole: boolean;
+  Missions: RawMission[];
+  Affiliations: RawAffiliation[];
+  DailyAffiliation: number;
+  DailyAffiliationPvp?: number;
+  DailyAffiliationLibrary?: number;
+  DailyAffiliationCetus?: number;
+  DailyAffiliationQuills?: number;
+  DailyAffiliationSolaris?: number;
+  DailyAffiliationVentkids?: number;
+  DailyAffiliationVox?: number;
+  DailyAffiliationEntrati?: number;
+  DailyAffiliationNecraloid?: number;
+  DailyAffiliationZariman?: number;
+  DailyAffiliationKahl?: number;
+  DailyAffiliationCavia?: number;
+  DailyAffiliationHex?: number;
+  DailyFocus?: number;
+  Wishlist?: any;
+  UnlockedOperator: boolean;
+  UnlockedAlignment: boolean;
+  OperatorLoadOuts: RawOperatorLoadOuts[];
+  Alignment: { Wisdom: number; Alignment: number };
+}
+
+/**
+ * A player's profile
+ * @module
+ */
+export default class Profile {
+  /**
+   * Player's account ID
+   */
+  accountId: string;
+
+  /**
+   * In-game name
+   */
+  displayName: string;
+
+  /**
+   * List of usernames across supported platforms
+   */
+  platformNames: string[];
+
+  /**
+   * Mastery rank
+   */
+  masteryRank: number;
+
+  /**
+   * Load out preset equipped
+   */
+  preset?: LoadOutPreset;
+
+  /**
+   * Current loadout
+   */
+  loadout: LoadOutInventory;
+
+  /**
+   * Railjack and drifter Intrinsics
+   */
+  intrinsics?: Intrinsics;
+
+  /**
+   * Nightwave challenges progress
+   */
+  challengeProgress: ChallengeProgress[];
+
+  /**
+   * Guild ID
+   */
+  guildId?: string;
+
+  /**
+   * Guild name
+   */
+  guildName?: string;
+
+  /**
+   * Guild tier
+   */
+  guildTier?: number;
+
+  /**
+   * Guild XP
+   */
+  guildXp?: number;
+
+  /**
+   * Guild class
+   */
+  guildClass?: number;
+
+  /**
+   * Guild emblem.
+   */
+  guildEmblem: boolean;
+
+  /**
+   * Alliance ID
+   */
+  allianceId?: string;
+
+  /**
+   * Assassins currently asfter the player
+   */
+  deathMarks: string[];
+
+  /**
+   * Whether or not the player is qualified as a target for Zanuka
+   * @type {boolean}
+   */
+  harvestable: boolean;
+
+  /**
+   * Whether or not the player is qualified as a target for a syndicate death squad
+   */
+  deathSquadable: boolean;
+
+  /**
+   * Date the account was created
+   */
+  created: Date;
+
+  /**
+   * Whether the user has migrated to console or not
+   */
+  migratedToConsole: boolean;
+
+  /**
+   * List of completed missions and their completions
+   */
+  missions: Mission[];
+
+  /**
+   * Player standing and title across all syndicates
+   */
+  syndicates?: Syndicate[];
+
+  /**
+   * Daily standing per Syndicate
+   *
+   * Faction syndicates all share daily standing
+   */
+  dailyStanding: {
+    daily: number;
+    conclave?: number;
+    simaris?: number;
+    ostron?: number;
+    quills?: number;
+    solaris?: number;
+    ventKids?: number;
+    voxSolaris?: number;
+    entrati?: number;
+    necraloid?: number;
+    holdfasts?: number;
+    kahl?: number;
+    cavia?: number;
+    hex?: number;
+  };
+
+  /**
+   * Daily focus
+   */
+  dailyFocus?: number;
+
+  /**
+   * Player wishlist for in-game market items
+   */
+  wishList: any;
+
+  /**
+   * Whether the player has unlocked their operator or not
+   */
+  unlockedOperator: boolean;
+
+  /**
+   * Whether the player has unlocked their alignment or not
+   */
+  unlockedAlignment: boolean;
+
+  /**
+   * Operator loadout
+   */
+  operatorLoadouts?: OperatorLoadOuts[];
+
+  /**
+   * Player's alignment
+   */
+  alignment?: { wisdom: number; alignment: number };
+
+  /**
+   *
+   * @param profile The profile data to parse
+   * @param locale The locale to return in where possible
+   * @param withItem Whether or not to include items
+   */
+  constructor(profile: RawProfile, locale: Locale = 'en', withItem: boolean = false) {
+    this.accountId = profile.AccountId.$oid;
+
+    this.displayName = profile.DisplayName;
+
+    this.platformNames = profile.PlatformNames ?? [];
+
+    this.masteryRank = profile.PlayerLevel;
+
+    if (profile.LoadOutPreset) this.preset = new LoadOutPreset(profile.LoadOutPreset);
+
+    this.loadout = new LoadOutInventory(profile.LoadOutInventory, locale, withItem);
+
+    this.intrinsics = new Intrinsics(profile.PlayerSkills ?? {});
+
+    this.challengeProgress = profile.ChallengeProgress.map((c) => new ChallengeProgress(c));
+
+    if (profile.GuildId?.$oid) this.guildId = profile.GuildId.$oid;
+
+    this.guildName = profile.GuildName;
+
+    this.guildTier = profile.GuildTier;
+
+    this.guildXp = profile.GuildXp;
+
+    this.guildClass = profile.GuildClass;
+
+    this.guildEmblem = profile.GuildEmblem;
+
+    if (profile.AllianceId) this.allianceId = profile.AllianceId.$oid;
+
+    this.deathMarks = profile.DeathMarks;
+
+    this.harvestable = profile.Harvestable;
+
+    this.deathSquadable = profile.DeathSquadable;
+
+    this.created = parseDate(profile.Created);
+
+    this.migratedToConsole = profile.MigratedToConsole;
+
+    this.missions = profile.Missions.map((m) => new Mission(m, locale));
+
+    this.syndicates = profile.Affiliations?.map((a) => new Syndicate(a, locale)) ?? [];
+
+    this.dailyStanding = {
+      daily: profile.DailyAffiliation,
+      conclave: profile.DailyAffiliationPvp,
+      simaris: profile.DailyAffiliationLibrary,
+      ostron: profile.DailyAffiliationCetus,
+      quills: profile.DailyAffiliationQuills,
+      solaris: profile.DailyAffiliationSolaris,
+      ventKids: profile.DailyAffiliationVentkids,
+      voxSolaris: profile.DailyAffiliationVox,
+      entrati: profile.DailyAffiliationEntrati,
+      necraloid: profile.DailyAffiliationNecraloid,
+      holdfasts: profile.DailyAffiliationZariman,
+      kahl: profile.DailyAffiliationKahl,
+      cavia: profile.DailyAffiliationCavia,
+      hex: profile.DailyAffiliationHex,
+    };
+
+    this.dailyFocus = profile.DailyFocus;
+
+    this.wishList = profile.Wishlist;
+
+    this.unlockedOperator = profile.UnlockedOperator;
+
+    this.unlockedAlignment = profile.UnlockedAlignment;
+
+    this.operatorLoadouts = profile.OperatorLoadOuts?.map((ol) => new OperatorLoadOuts(ol, locale));
+
+    if (profile.Alignment) {
+      this.alignment = { wisdom: profile.Alignment?.Wisdom, alignment: profile.Alignment?.Alignment };
+    }
+  }
+}

package/src/ProfileParser.ts

@@ -0,0 +1,66 @@
+import { parseDate } from 'warframe-worldstate-data/utilities';
+
+import Profile, { type RawProfile } from './Profile';
+import Stats, { type RawStats } from './Stats';
+import type { RawDate } from './Utils';
+import { Locale } from 'warframe-worldstate-data';
+
+interface ProfileData {
+  Results: RawProfile[];
+  TechProjects?: any;
+  XpCompoents?: any;
+  XpCacheExpiryDate?: RawDate;
+  CeremonyResetDate?: RawDate;
+  Stats: RawStats;
+}
+
+/**
+ * Parser entry point
+ * @module
+ */
+export default class ProfileParser {
+  /**
+   * Player's profile
+   */
+  profile: Profile;
+
+  /**
+   * N/A
+   */
+  techProjects: any;
+
+  /**
+   * N/A
+   */
+  xpComponents: any;
+
+  /**
+   * N/A
+   */
+  xpCacheExpiryDate: Date;
+
+  /**
+   * N/A
+   */
+  ceremonyResetDate: Date;
+
+  /**
+   * Player stats
+   */
+  stats: Stats;
+
+  /**
+   *
+   * @param {Object} data The data returned by getProfile endpoint
+   * @param {string} locale The locale to return where possible
+   * @param {boolean} [withItem=false] Whether or not to include items
+   */
+  constructor(data: ProfileData, locale: Locale = 'en', withItem: boolean = false) {
+    this.profile = new Profile(data.Results[0], locale, withItem);
+    this.techProjects = data.TechProjects;
+    this.xpComponents = data.XpCompoents;
+    this.xpCacheExpiryDate = parseDate(data.XpCacheExpiryDate);
+    this.ceremonyResetDate = parseDate(data.CeremonyResetDate);
+    this.stats = new Stats(data.Stats);
+  }
+}

package/src/Pvp.ts

@@ -0,0 +1,43 @@
+export interface RawPvp {
+  type: string;
+  suitDeaths?: number;
+  suitKills?: number;
+  weaponKills?: number;
+}
+
+/**
+ * Player's conclave stats
+ * @module
+ */
+export default class Pvp {
+  /**
+   * PVP match unique name
+   */
+  uniqueName: string;
+
+  /**
+   * Deaths for this match
+   */
+  warframeDeaths?: number;
+
+  /**
+   * Warframe kills
+   */
+  warframeKills?: number;
+
+  /**
+   * Weapon killes
+   */
+  weaponKills?: number;
+
+  /**
+   *
+   * @param {Object} pvp PVP data to parse
+   */
+  constructor(pvp: RawPvp) {
+    this.uniqueName = pvp.type;
+    this.warframeDeaths = pvp.suitDeaths;
+    this.warframeKills = pvp.suitKills;
+    this.weaponKills = pvp.weaponKills;
+  }
+}

package/src/Race.ts

@@ -0,0 +1,36 @@
+
+export type RawRace =  Record<string, { highScore: number }>;
+
+/**
+ * Represents a k-drive race
+ * @module
+ */
+export default class Race {
+  /**
+   * Race name
+   */
+  uniqueName: string;
+  /**
+   * Race High score
+   */
+  highScore: number;
+
+  /**
+   *
+   * @param type Race name
+   * @param highScore high score
+   */
+  constructor(type: string, highScore: number) {
+    this.uniqueName = type;
+    this.highScore = highScore;
+  }
+
+  /**
+   * Created an array of Race objects from DE's Races array
+   * @param races Array of races
+   * @returns {Race[]} An array of races formatted in a more consumable way.
+   */
+  static fromRaceObject(races: RawRace) {
+    return Object.entries(races ?? {}).map(([type, { highScore }]) => new Race(type, highScore));
+  }
+}

package/src/Scan.ts

@@ -0,0 +1,30 @@
+export interface RawScan {
+  type: string;
+  scans: number;
+}
+
+/**
+ * Represents an enemy scanned to the codex
+ * @module
+ */
+export default class Scan {
+  /**
+   * Enemy unique name
+   * @type {String}
+   */
+  uniqueName: string;
+
+  /**
+   * Number of scans done
+   * @type {number}
+   */
+  scans: number;
+
+  /**
+   * @param {Object} scan The scanned Warframe object
+   */
+  constructor(scan: RawScan) {
+    this.uniqueName = scan.type;
+    this.scans = scan.scans;
+  }
+}

package/src/{Skin.js → Skin.ts}

@@ -1,23 +1,31 @@
-import { find } from './Utils.js';
+import type { Item } from '@wfcd/items';
+import { find } from './Utils';
+
+export interface RawSkin {
+  ItemType: string
+}
 
 /**
  * A skin class
  * @module
  */
 export default class Skin {
+  uniqueName: string;
+  item?: Item;
+
   /**
    *
-   * @param {Object} skin The skin data  to parse
-   * @param {string} [locale='en'] The locale to return skin item in
+   * @param skin The skin data  to parse
+   * @param locale The locale to return skin item in
    */
-  constructor(skin, locale = 'en') {
+  constructor(skin: RawSkin, locale = 'en') {
     /**
      * Unique name
-     * @type {String}
      */
     this.uniqueName = skin.ItemType;
 
     const item = find(skin.ItemType, locale);
+
     /**
      * The Warframe item that matches the unique name
      */
@@ -30,4 +38,4 @@ export default class Skin {
  * @param {Object} skin Skin object
  * @returns {Skin} Skin object with possible item
  */
-export const WeaponSkin = (skin) => new Skin(skin);
+export const WeaponSkin = (skin: RawSkin) => new Skin(skin);