valtech-components 4.0.442 → 4.0.444

package/esm2022/lib/components/organisms/mini-games/chessimals-challenge-progress.service.mjs

@@ -0,0 +1,145 @@
+import { Injectable, inject } from '@angular/core';
+import { Auth } from '@angular/fire/auth';
+import { Firestore, collection, doc, getDoc, limit, onSnapshot, orderBy, query, serverTimestamp, setDoc, } from '@angular/fire/firestore';
+import { Observable, of } from 'rxjs';
+import { FirebaseService } from '../../../services/firebase/firebase.service';
+import * as i0 from "@angular/core";
+const EMPTY_POWERS = { eagle: 0, bull: 0, kangaroo: 0, lion: 0 };
+export class ChessimalsChallengeProgressService {
+    constructor() {
+        this.firebaseAuth = inject(Auth);
+        this.firestore = inject(Firestore);
+        this.firebase = inject(FirebaseService);
+    }
+    get currentUid() {
+        return this.firebaseAuth.currentUser?.uid;
+    }
+    watchStats() {
+        const uid = this.currentUid;
+        if (!uid)
+            return of(undefined);
+        return new Observable((subscriber) => {
+            const unsubscribe = onSnapshot(this.statsRef(uid), (snapshot) => subscriber.next(snapshot.exists() ? this.normalizeStats(snapshot.data()) : undefined), (error) => subscriber.error(error));
+            return unsubscribe;
+        });
+    }
+    watchRecentRuns(limitCount = 4) {
+        const uid = this.currentUid;
+        if (!uid)
+            return of([]);
+        const runsQuery = query(collection(this.firestore, this.runsPath(uid)), orderBy('updatedAt', 'desc'), limit(limitCount));
+        return new Observable((subscriber) => {
+            const unsubscribe = onSnapshot(runsQuery, (snapshot) => subscriber.next(snapshot.docs.map((item) => item.data())), (error) => subscriber.error(error));
+            return unsubscribe;
+        });
+    }
+    async saveRun(run) {
+        const uid = await this.ensureUser();
+        await setDoc(this.runRef(uid, run.id), this.withoutUndefined({
+            ...run,
+            userId: uid,
+            updatedAt: new Date().toISOString(),
+            updatedAtServer: serverTimestamp(),
+        }), { merge: true });
+    }
+    async recordChallengeStarted(run) {
+        const uid = await this.ensureUser();
+        const current = await this.readStats(uid);
+        await setDoc(this.statsRef(uid), {
+            ...current,
+            userId: uid,
+            challengesPlayed: current.challengesPlayed + 1,
+            updatedAt: new Date().toISOString(),
+            updatedAtServer: serverTimestamp(),
+        }, { merge: true });
+        await this.saveRun(run);
+    }
+    async applyRoundResult(args) {
+        const uid = await this.ensureUser();
+        const current = await this.readStats(uid);
+        const next = {
+            userId: uid,
+            challengesPlayed: current.challengesPlayed,
+            challengesCompleted: current.challengesCompleted + (args.completed ? 1 : 0),
+            bestWinStreak: Math.max(current.bestWinStreak, args.run.bestStreakInRun),
+            bestRoundReached: Math.max(current.bestRoundReached, args.roundReached),
+            totalWins: current.totalWins + (args.won ? 1 : 0),
+            totalLosses: current.totalLosses + (args.won ? 0 : 1),
+            botsDefeated: current.botsDefeated + (args.won ? 1 : 0),
+            powersUsed: {
+                eagle: current.powersUsed.eagle + args.roundStats.powersUsed.eagle,
+                bull: current.powersUsed.bull + args.roundStats.powersUsed.bull,
+                kangaroo: current.powersUsed.kangaroo + args.roundStats.powersUsed.kangaroo,
+                lion: current.powersUsed.lion + args.roundStats.powersUsed.lion,
+            },
+            powerCaptures: current.powerCaptures + args.roundStats.powerCaptures,
+            promotions: current.promotions + args.roundStats.promotions,
+            updatedAt: new Date().toISOString(),
+        };
+        await setDoc(this.statsRef(uid), { ...next, updatedAtServer: serverTimestamp() }, { merge: true });
+        await this.saveRun(args.run);
+    }
+    emptyStats() {
+        return {
+            challengesPlayed: 0,
+            challengesCompleted: 0,
+            bestWinStreak: 0,
+            bestRoundReached: 0,
+            totalWins: 0,
+            totalLosses: 0,
+            botsDefeated: 0,
+            powersUsed: { ...EMPTY_POWERS },
+            powerCaptures: 0,
+            promotions: 0,
+        };
+    }
+    async readStats(uid) {
+        // Firestore's web SDK does not need a transaction for these casual game stats.
+        // Last-write-wins is acceptable for this first version because one run is active per browser.
+        const snapshot = await getDoc(this.statsRef(uid));
+        return snapshot.exists() ? this.normalizeStats(snapshot.data()) : this.emptyStats();
+    }
+    normalizeStats(value) {
+        const empty = this.emptyStats();
+        return {
+            ...empty,
+            ...value,
+            powersUsed: {
+                ...EMPTY_POWERS,
+                ...(value.powersUsed ?? {}),
+            },
+        };
+    }
+    async ensureUser() {
+        await this.firebase.whenFirebaseAuthReady();
+        const user = this.firebaseAuth.currentUser;
+        if (user?.uid) {
+            await user.getIdToken();
+            return user.uid;
+        }
+        throw new Error('CHESSIMALS_CHALLENGE_LOGIN_REQUIRED');
+    }
+    statsRef(uid) {
+        return doc(this.firestore, `users/${uid}/miniGames/chessimals/challenge/stats`);
+    }
+    runRef(uid, runId) {
+        return doc(this.firestore, `${this.runsPath(uid)}/${runId}`);
+    }
+    runsPath(uid) {
+        return `users/${uid}/miniGames/chessimals/challengeRuns`;
+    }
+    withoutUndefined(value) {
+        return Object.entries(value).reduce((acc, [key, entry]) => {
+            if (entry !== undefined)
+                acc[key] = entry;
+            return acc;
+        }, {});
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ChessimalsChallengeProgressService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ChessimalsChallengeProgressService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ChessimalsChallengeProgressService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"chessimals-challenge-progress.service.js","sourceRoot":"","sources":["../../../../../../../src/lib/components/organisms/mini-games/chessimals-challenge-progress.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, inject } from '@angular/core';\nimport { Auth } from '@angular/fire/auth';\nimport {\n  Firestore,\n  collection,\n  doc,\n  getDoc,\n  limit,\n  onSnapshot,\n  orderBy,\n  query,\n  serverTimestamp,\n  setDoc,\n} from '@angular/fire/firestore';\nimport { Observable, of } from 'rxjs';\n\nimport { FirebaseService } from '../../../services/firebase/firebase.service';\nimport {\n  ChessimalsChallengeRoundStats,\n  ChessimalsChallengeRun,\n  ChessimalsChallengeStats,\n} from './types';\n\nconst EMPTY_POWERS = { eagle: 0, bull: 0, kangaroo: 0, lion: 0 };\n\n@Injectable({ providedIn: 'root' })\nexport class ChessimalsChallengeProgressService {\n  private readonly firebaseAuth = inject(Auth);\n  private readonly firestore = inject(Firestore);\n  private readonly firebase = inject(FirebaseService);\n\n  get currentUid(): string | undefined {\n    return this.firebaseAuth.currentUser?.uid;\n  }\n\n  watchStats(): Observable<ChessimalsChallengeStats | undefined> {\n    const uid = this.currentUid;\n    if (!uid) return of(undefined);\n    return new Observable((subscriber) => {\n      const unsubscribe = onSnapshot(\n        this.statsRef(uid),\n        (snapshot) => subscriber.next(\n          snapshot.exists() ? this.normalizeStats(snapshot.data() as Partial<ChessimalsChallengeStats>) : undefined,\n        ),\n        (error) => subscriber.error(error),\n      );\n      return unsubscribe;\n    });\n  }\n\n  watchRecentRuns(limitCount = 4): Observable<ChessimalsChallengeRun[]> {\n    const uid = this.currentUid;\n    if (!uid) return of([]);\n    const runsQuery = query(\n      collection(this.firestore, this.runsPath(uid)),\n      orderBy('updatedAt', 'desc'),\n      limit(limitCount),\n    );\n    return new Observable((subscriber) => {\n      const unsubscribe = onSnapshot(\n        runsQuery,\n        (snapshot) => subscriber.next(snapshot.docs.map((item) => item.data() as ChessimalsChallengeRun)),\n        (error) => subscriber.error(error),\n      );\n      return unsubscribe;\n    });\n  }\n\n  async saveRun(run: ChessimalsChallengeRun): Promise<void> {\n    const uid = await this.ensureUser();\n    await setDoc(this.runRef(uid, run.id), this.withoutUndefined({\n      ...run,\n      userId: uid,\n      updatedAt: new Date().toISOString(),\n      updatedAtServer: serverTimestamp(),\n    }), { merge: true });\n  }\n\n  async recordChallengeStarted(run: ChessimalsChallengeRun): Promise<void> {\n    const uid = await this.ensureUser();\n    const current = await this.readStats(uid);\n    await setDoc(this.statsRef(uid), {\n      ...current,\n      userId: uid,\n      challengesPlayed: current.challengesPlayed + 1,\n      updatedAt: new Date().toISOString(),\n      updatedAtServer: serverTimestamp(),\n    }, { merge: true });\n    await this.saveRun(run);\n  }\n\n  async applyRoundResult(args: {\n    run: ChessimalsChallengeRun;\n    roundReached: number;\n    won: boolean;\n    completed: boolean;\n    roundStats: ChessimalsChallengeRoundStats;\n  }): Promise<void> {\n    const uid = await this.ensureUser();\n    const current = await this.readStats(uid);\n    const next: ChessimalsChallengeStats = {\n      userId: uid,\n      challengesPlayed: current.challengesPlayed,\n      challengesCompleted: current.challengesCompleted + (args.completed ? 1 : 0),\n      bestWinStreak: Math.max(current.bestWinStreak, args.run.bestStreakInRun),\n      bestRoundReached: Math.max(current.bestRoundReached, args.roundReached),\n      totalWins: current.totalWins + (args.won ? 1 : 0),\n      totalLosses: current.totalLosses + (args.won ? 0 : 1),\n      botsDefeated: current.botsDefeated + (args.won ? 1 : 0),\n      powersUsed: {\n        eagle: current.powersUsed.eagle + args.roundStats.powersUsed.eagle,\n        bull: current.powersUsed.bull + args.roundStats.powersUsed.bull,\n        kangaroo: current.powersUsed.kangaroo + args.roundStats.powersUsed.kangaroo,\n        lion: current.powersUsed.lion + args.roundStats.powersUsed.lion,\n      },\n      powerCaptures: current.powerCaptures + args.roundStats.powerCaptures,\n      promotions: current.promotions + args.roundStats.promotions,\n      updatedAt: new Date().toISOString(),\n    };\n    await setDoc(this.statsRef(uid), { ...next, updatedAtServer: serverTimestamp() }, { merge: true });\n    await this.saveRun(args.run);\n  }\n\n  emptyStats(): ChessimalsChallengeStats {\n    return {\n      challengesPlayed: 0,\n      challengesCompleted: 0,\n      bestWinStreak: 0,\n      bestRoundReached: 0,\n      totalWins: 0,\n      totalLosses: 0,\n      botsDefeated: 0,\n      powersUsed: { ...EMPTY_POWERS },\n      powerCaptures: 0,\n      promotions: 0,\n    };\n  }\n\n  private async readStats(uid: string): Promise<ChessimalsChallengeStats> {\n    // Firestore's web SDK does not need a transaction for these casual game stats.\n    // Last-write-wins is acceptable for this first version because one run is active per browser.\n    const snapshot = await getDoc(this.statsRef(uid));\n    return snapshot.exists() ? this.normalizeStats(snapshot.data() as Partial<ChessimalsChallengeStats>) : this.emptyStats();\n  }\n\n  private normalizeStats(value: Partial<ChessimalsChallengeStats>): ChessimalsChallengeStats {\n    const empty = this.emptyStats();\n    return {\n      ...empty,\n      ...value,\n      powersUsed: {\n        ...EMPTY_POWERS,\n        ...(value.powersUsed ?? {}),\n      },\n    };\n  }\n\n  private async ensureUser(): Promise<string> {\n    await this.firebase.whenFirebaseAuthReady();\n    const user = this.firebaseAuth.currentUser;\n    if (user?.uid) {\n      await user.getIdToken();\n      return user.uid;\n    }\n    throw new Error('CHESSIMALS_CHALLENGE_LOGIN_REQUIRED');\n  }\n\n  private statsRef(uid: string) {\n    return doc(this.firestore, `users/${uid}/miniGames/chessimals/challenge/stats`);\n  }\n\n  private runRef(uid: string, runId: string) {\n    return doc(this.firestore, `${this.runsPath(uid)}/${runId}`);\n  }\n\n  private runsPath(uid: string): string {\n    return `users/${uid}/miniGames/chessimals/challengeRuns`;\n  }\n\n  private withoutUndefined<T extends Record<string, unknown>>(value: T): T {\n    return Object.entries(value).reduce((acc, [key, entry]) => {\n      if (entry !== undefined) acc[key as keyof T] = entry as T[keyof T];\n      return acc;\n    }, {} as T);\n  }\n}\n"]}