halo-infinite-api 4.1.0 → 5.1.0

package/src/core/xbox-client.ts

@@ -0,0 +1,53 @@
+import { XboxTokenProvider } from "./token-providers/xbox-token-provider";
+
+export class XboxClient {
+  private readonly fetchFn: typeof fetch;
+  constructor(
+    private xboxTokenProvider: XboxTokenProvider,
+    fetchFn?: typeof fetch
+  ) {
+    this.fetchFn = fetchFn ?? fetch;
+  }
+
+  private async executeRequest<T>(url: string, method: RequestInit["method"]) {
+    const response = await this.fetchFn(url, {
+      method,
+      headers: {
+        Accept: "application/json",
+        Authorization: await this.xboxTokenProvider.getXboxLiveV3Token(),
+        "x-xbl-contract-version": "1",
+      },
+    });
+
+    const result = (await response.json()) as T;
+
+    return result;
+  }
+
+  public async searchUsers(query: string) {
+    const { results } = await this.executeRequest<{
+      results: [
+        {
+          result: {
+            id: string;
+            gamertag: string;
+            displayPicUri: string;
+            score: 0.0;
+          };
+          text: string;
+        }
+      ];
+    }>(
+      `https://usersearch.xboxlive.com/suggest?q=${encodeURIComponent(query)}`,
+      "GET"
+    );
+    return results.map(({ result }) => result);
+  }
+
+  public async recentPlayers() {
+    return await this.executeRequest<unknown>(
+      "https://peoplehub.xboxlive.com/users/me/people/recentplayers",
+      "GET"
+    );
+  }
+}

package/src/index.ts

@@ -2,6 +2,7 @@ export {
   HaloInfiniteClient,
   AssetKindTypeMap,
 } from "./core/halo-infinite-client";
+export { XboxClient } from "./core/xbox-client";
 export {
   XboxAuthenticationClient,
   RelyingParty,
@@ -21,8 +22,11 @@ export { MatchOutcome } from "./models/halo-infinite/match-outcome";
 export { MatchSkill } from "./models/halo-infinite/match-skill";
 export { AssetVersionLink } from "./models/halo-infinite/asset-version-link";
 export { MatchInfo } from "./models/halo-infinite/match-info";
-export { SpartanTokenProvider } from "./core/spartan-token-providers";
-export { AutoXstsSpartanTokenProvider } from "./core/spartan-token-providers/auto-xsts-spartan-token-provider";
-export { StaticXstsTicketTokenSpartanTokenProvider } from "./core/spartan-token-providers/static-xsts-ticket-token-spartan-token-provider";
+export { SpartanTokenProvider } from "./core/token-providers/spartan-token-providers";
+export {
+  AutoTokenProvider,
+  AutoTokenProvider as AutoXstsSpartanTokenProvider,
+} from "./core/token-providers/auto-token-provider";
+export { StaticXstsTicketTokenSpartanTokenProvider } from "./core/token-providers/spartan-token-providers/static-xsts-ticket-token-spartan-token-provider";
 export { TokenPersister } from "./core/token-persisters";
 export { PlaylistExperience } from "./models/halo-infinite/playlist-experience";

package/src/models/halo-infinite/game-variant-category.ts

@@ -7,6 +7,7 @@ export enum GameVariantCategory {
   MultiplayerTotalControl = 14,
   MultiplayerCtf = 15,
   MultiplayerOddball = 18,
+  MultiplayerStockpile = 19,
   MultiplayerInfection = 22,
   MultiplayerGrifball = 25,
   MultiplayerLandGrab = 39,

package/src/models/halo-infinite/stats.ts

@@ -1,6 +1,6 @@
 import { GameVariantCategory } from "./game-variant-category";
 
-interface OddballStats {
+export interface OddballStats {
   KillsAsSkullCarrier: number;
   LongestTimeAsSkullCarrier: string;
   SkullCarriersKilled: number;
@@ -8,7 +8,8 @@ interface OddballStats {
   TimeAsSkullCarrier: string;
   SkullScoringTicks: number;
 }
-interface ZonesStats {
+
+export interface ZonesStats {
   StrongholdCaptures: number;
   StrongholdDefensiveKills: number;
   StrongholdOffensiveKills: number;
@@ -16,7 +17,8 @@ interface ZonesStats {
   StrongholdOccupationTime: string;
   StrongholdScoringTicks: number;
 }
-interface CaptureTheFlagStats {
+
+export interface CaptureTheFlagStats {
   FlagCaptureAssists: number;
   FlagCaptures: number;
   FlagCarriersKilled: number;
@@ -30,7 +32,7 @@ interface CaptureTheFlagStats {
   TimeAsFlagCarrier: string;
 }
 
-interface ExtractionStats {
+export interface ExtractionStats {
   SuccessfulExtractions: number;
   ExtractionConversionsDenied: number;
   ExtractionConversionsCompleted: number;
@@ -38,6 +40,42 @@ interface ExtractionStats {
   ExtractionInitiationsCompleted: number;
 }
 
+export interface EliminationStats {
+  AlliesRevived: number;
+  EliminationAssists: number;
+  Eliminations: number;
+  EnemyRevivesDenied: number;
+  Executions: number;
+  KillsAsLastPlayerStanding: number;
+  LastPlayersStandingKilled: number;
+  RoundsSurvived: number;
+  TimesRevivedByAlly: number;
+}
+
+export interface InfectionStats {
+  AlphasKilled: number;
+  SpartansInfected: number;
+  SpartansInfectedAsAlpha: number;
+  KillsAsLastSpartanStanding: number;
+  LastSpartansStandingInfected: number;
+  RoundsAsAlpha: number;
+  RoundsAsLastSpartanStanding: number;
+  RoundsFinishedAsInfected: number;
+  RoundsSurvivedAsSpartan: number;
+  RoundsSurvivedAsLastSpartanStanding: number;
+  TimeAsLastSpartanStanding: string;
+  InfectedKilled: number;
+}
+
+export interface StockpileStats {
+  KillsAsPowerSeedCarrier: number;
+  PowerSeedCarriersKilled: number;
+  PowerSeedsDeposited: number;
+  PowerSeedsStolen: number;
+  TimeAsPowerSeedCarrier: string;
+  TimeAsPowerSeedDriver: string;
+}
+
 type StatsMap = {
   [GameVariantCategory.MultiplayerOddball]: { OddballStats: OddballStats };
   [GameVariantCategory.MultiplayerStrongholds]: { ZonesStats: ZonesStats };
@@ -49,7 +87,13 @@ type StatsMap = {
     ExtractionStats: ExtractionStats;
   };
   [GameVariantCategory.MultiplayerFirefight]: {
-    ExtractionStats: ExtractionStats;
+    EliminationStats: EliminationStats;
+  };
+  [GameVariantCategory.MultiplayerInfection]: {
+    InfectionSTats: InfectionStats;
+  };
+  [GameVariantCategory.MultiplayerStockpile]: {
+    StockpileStats: StockpileStats;
   };
 };
 

package/src/util/keyed-expiry-token-cache.ts

@@ -0,0 +1,90 @@
+import { DateTime } from "luxon";
+import { ResolvablePromise } from "./resolvable-promise";
+import { coalesceDateTime } from "./date-time";
+
+export class KeyedExpiryTokenCache<
+  TToken extends { expiresAt: DateTime },
+  TKey extends string,
+  TArgs extends any[]
+> {
+  private readonly tokenFetchPromiseMap = new Map<
+    TKey,
+    ResolvablePromise<TToken>
+  >();
+
+  constructor(
+    private readonly generateNewToken: (
+      key: TKey,
+      ...args: TArgs
+    ) => Promise<TToken>,
+    private readonly existingTokenFetcher: (
+      key: TKey
+    ) => Promise<(Omit<TToken, "expiresAt"> & { expiresAt: unknown }) | null>
+  ) {}
+
+  async getToken(key: TKey, ...args: TArgs): Promise<TToken> {
+    let tokenFetchPromise = this.tokenFetchPromiseMap.get(key);
+    if (tokenFetchPromise) {
+      // Someone either already has a token or is in the process of getting one
+      // Wait for them to finish, then check for validity
+      const currentToken = await tokenFetchPromise;
+
+      if (currentToken.expiresAt > DateTime.now()) {
+        // Current token is valid, return it
+        return currentToken;
+      } else {
+        // Current token expired, start a new promise
+        tokenFetchPromise = new ResolvablePromise<TToken>();
+        this.tokenFetchPromiseMap.set(key, tokenFetchPromise);
+
+        try {
+          const newToken = await this.generateNewToken(key, ...args);
+          tokenFetchPromise.resolve(newToken);
+          return newToken;
+        } catch (e) {
+          tokenFetchPromise.reject(e);
+          tokenFetchPromise = undefined;
+          throw e;
+        }
+      }
+    } else {
+      // No one has a token, start a new promise
+      tokenFetchPromise = new ResolvablePromise<TToken>();
+      this.tokenFetchPromiseMap.set(key, tokenFetchPromise);
+
+      try {
+        const existingToken = await this.getExistingToken(key);
+
+        if (existingToken?.expiresAt) {
+          const expiresAt = coalesceDateTime(existingToken.expiresAt);
+          if (expiresAt && expiresAt > DateTime.now()) {
+            const newToken = { ...existingToken, expiresAt } as TToken;
+            tokenFetchPromise.resolve(newToken);
+            return newToken;
+          }
+        }
+
+        const newToken = await this.generateNewToken(key, ...args);
+        tokenFetchPromise.resolve(newToken);
+        return newToken;
+      } catch (e) {
+        tokenFetchPromise.reject(e);
+        tokenFetchPromise = undefined;
+        throw e;
+      }
+    }
+  }
+
+  async getExistingToken(key: TKey) {
+    const existingToken = await this.existingTokenFetcher(key);
+
+    if (existingToken?.expiresAt) {
+      const expiresAt = coalesceDateTime(existingToken.expiresAt);
+      if (expiresAt && expiresAt > DateTime.now()) {
+        return { ...existingToken, expiresAt } as TToken;
+      }
+    }
+
+    return null;
+  }
+}