sekai-calculator 0.4.4 → 0.5.1

package/dist/index.cjs

@@ -35,6 +35,45 @@ function containsAny(collection, contains) {
     return false;
 }
 
+class CachedDataProvider {
+    dataProvider;
+    constructor(dataProvider) {
+        this.dataProvider = dataProvider;
+    }
+    static globalCache = new Map();
+    instanceCache = new Map();
+    static runningPromise = new Map();
+    async getData(cache, cacheKey, promise) {
+        if (cache.has(cacheKey))
+            return cache.get(cacheKey);
+        while (CachedDataProvider.runningPromise.has(cacheKey)) {
+            await CachedDataProvider.runningPromise.get(cacheKey);
+        }
+        if (cache.has(cacheKey))
+            return cache.get(cacheKey);
+        CachedDataProvider.runningPromise.set(cacheKey, promise());
+        const data = await getOrThrow(CachedDataProvider.runningPromise, cacheKey).then(data => {
+            cache.set(cacheKey, data);
+            return data;
+        });
+        CachedDataProvider.runningPromise.delete(cacheKey);
+        return data;
+    }
+    async getMasterData(key) {
+        return await this.getData(CachedDataProvider.globalCache, key, async () => await this.dataProvider.getMasterData(key));
+    }
+    async getMusicMeta() {
+        return await this.getData(CachedDataProvider.globalCache, 'musicMeta', async () => await this.dataProvider.getMusicMeta());
+    }
+    async getUserData(key) {
+        const allData = await this.getUserDataAll();
+        return allData[key];
+    }
+    async getUserDataAll() {
+        return await this.getData(this.instanceCache, 'userData', async () => await this.dataProvider.getUserDataAll());
+    }
+}
+
 class DeckService {
     dataProvider;
     constructor(dataProvider) {
@@ -300,13 +339,40 @@ class CardCalculator {
         units.push(findOrThrow(gameCharacters, it => it.id === card.characterId).unit);
         return units;
     }
-    async getCardDetail(userCard, userAreaItemLevels, eventId = 0) {
+    async applyCardConfig(userCard, card, { rankMax = false, episodeRead = false, masterMax = false, skillMax = false }) {
+        if (!rankMax && !episodeRead && !masterMax && !skillMax)
+            return userCard;
+        const cardRarities = await this.dataProvider.getMasterData('cardRarities');
+        const cardRarity = findOrThrow(cardRarities, it => it.cardRarityType === card.cardRarityType);
+        const ret = JSON.parse(JSON.stringify(userCard));
+        if (rankMax) {
+            if (cardRarity.trainingMaxLevel !== undefined) {
+                ret.level = cardRarity.trainingMaxLevel;
+                ret.specialTrainingStatus = 'done';
+            }
+            else {
+                ret.level = cardRarity.maxLevel;
+            }
+        }
+        if (episodeRead) {
+            ret.episodes.forEach(it => { it.scenarioStatus = 'already_read'; });
+        }
+        if (masterMax) {
+            ret.masterRank = 5;
+        }
+        if (skillMax) {
+            ret.skillLevel = cardRarity.maxSkillLevel;
+        }
+        return ret;
+    }
+    async getCardDetail(userCard, userAreaItemLevels, config = {}, eventId = 0) {
         const cards = await this.dataProvider.getMasterData('cards');
         const card = findOrThrow(cards, it => it.id === userCard.cardId);
         const units = await this.getCardUnits(card);
-        const skill = await this.skillCalculator.getCardSkill(userCard, card);
-        const power = await this.powerCalculator.getCardPower(userCard, card, units, userAreaItemLevels);
-        const eventBonus = eventId === 0 ? undefined : await this.eventCalculator.getCardEventBonus(userCard, eventId);
+        const userCard0 = await this.applyCardConfig(userCard, card, config);
+        const skill = await this.skillCalculator.getCardSkill(userCard0, card);
+        const power = await this.powerCalculator.getCardPower(userCard0, card, units, userAreaItemLevels);
+        const eventBonus = eventId === 0 ? undefined : await this.eventCalculator.getCardEventBonus(userCard0, eventId);
         return {
             cardId: card.id,
             characterId: card.characterId,
@@ -318,11 +384,11 @@ class CardCalculator {
             eventBonus
         };
     }
-    async batchGetCardDetail(userCards, eventId = 0) {
+    async batchGetCardDetail(userCards, config = {}, eventId = 0) {
         const areaItemLevels = await this.dataProvider.getMasterData('areaItemLevels');
         const userAreas = await this.dataProvider.getUserData('userAreas');
         const userItemLevels = userAreas.flatMap(it => it.areaItems).map(areaItem => findOrThrow(areaItemLevels, it => it.areaItemId === areaItem.areaItemId && it.level === areaItem.level));
-        return await Promise.all(userCards.map(async (it) => await this.getCardDetail(it, userItemLevels, eventId)));
+        return await Promise.all(userCards.map(async (it) => await this.getCardDetail(it, userItemLevels, config, eventId)));
     }
     static isCertainlyLessThan(cardDetail0, cardDetail1) {
         return cardDetail0.power.isCertainlyLessThen(cardDetail1.power) &&
@@ -545,7 +611,7 @@ class BaseDeckRecommend {
     }
     static filterCard(cardDetails) {
         let afterFilter = cardDetails;
-        for (const minBonus of [65, 50, 40, 25, 15, 0]) {
+        for (const minBonus of [55, 50, 45, 40, 30, 25, 15, 5, 0]) {
             const bonusFilter = cardDetails.filter(cardDetail => !(cardDetail.eventBonus !== undefined && cardDetail.eventBonus < minBonus));
             if (this.canMakeEventDeck(bonusFilter)) {
                 afterFilter = bonusFilter;
@@ -593,8 +659,8 @@ class BaseDeckRecommend {
             throw new Error(`Cannot find deck in ${cardDetails.length} cards`);
         return ans;
     }
-    async recommendHighScoreDeck(userCards, musicMeta, scoreFunc, limit = 1, eventId = 0, isChallengeLive = false, member = 5) {
-        const cards = await this.cardCalculator.batchGetCardDetail(userCards, eventId);
+    async recommendHighScoreDeck(userCards, scoreFunc, { musicMeta, limit = 1, member = 5, cardConfig = {} }, eventId = 0, isChallengeLive = false) {
+        const cards = await this.cardCalculator.batchGetCardDetail(userCards, cardConfig, eventId);
         let cardDetails = (isChallengeLive || eventId === 0) ? cards : BaseDeckRecommend.filterCard(cards);
         cardDetails = cardDetails.sort((a, b) => a.cardId - b.cardId);
         const honorBonus = await this.deckCalculator.getHonorBonusPower();
@@ -615,12 +681,12 @@ class ChallengeLiveDeckRecommend {
         this.dataProvider = dataProvider;
         this.baseRecommend = new BaseDeckRecommend(dataProvider);
     }
-    async recommendChallengeLiveDeck(characterId, musicMeta, limit = 1, member = 5) {
+    async recommendChallengeLiveDeck(characterId, config) {
         const userCards = await this.dataProvider.getUserData('userCards');
         const cards = await this.dataProvider.getMasterData('cards');
         const characterCards = userCards
             .filter(userCard => findOrThrow(cards, it => it.id === userCard.cardId).characterId === characterId);
-        const recommend = await this.baseRecommend.recommendHighScoreDeck(characterCards, musicMeta, BaseDeckRecommend.getLiveScoreFunction(exports.LiveType.SOLO), limit, 0, true, member);
+        const recommend = await this.baseRecommend.recommendHighScoreDeck(characterCards, BaseDeckRecommend.getLiveScoreFunction(exports.LiveType.SOLO), config, 0, true);
         return recommend.map(it => {
             return {
                 score: it.score,
@@ -638,9 +704,9 @@ class EventDeckRecommend {
         this.dataProvider = dataProvider;
         this.baseRecommend = new BaseDeckRecommend(dataProvider);
     }
-    async recommendEventDeck(eventId, musicMeta, liveType, limit = 1) {
+    async recommendEventDeck(eventId, liveType, config) {
         const userCards = await this.dataProvider.getUserData('userCards');
-        const recommend = await this.baseRecommend.recommendHighScoreDeck(userCards, musicMeta, BaseDeckRecommend.getEventPointFunction(liveType), limit, eventId);
+        const recommend = await this.baseRecommend.recommendHighScoreDeck(userCards, BaseDeckRecommend.getEventPointFunction(liveType), config, eventId);
         return recommend.map(it => {
             return {
                 point: it.score,
@@ -684,6 +750,7 @@ class MusicRecommend {
     }
 }
 
+exports.CachedDataProvider = CachedDataProvider;
 exports.CardCalculator = CardCalculator;
 exports.CardEventCalculator = CardEventCalculator;
 exports.CardPowerCalculator = CardPowerCalculator;

package/dist/index.d.ts

@@ -1,9 +1,23 @@
 interface DataProvider {
     getMasterData: (key: string) => Promise<any>;
+    getUserDataAll: () => Promise<any>;
     getUserData: (key: string) => Promise<any>;
     getMusicMeta: () => Promise<any>;
 }
 
+declare class CachedDataProvider implements DataProvider {
+    private readonly dataProvider;
+    constructor(dataProvider: DataProvider);
+    private static readonly globalCache;
+    private readonly instanceCache;
+    private static readonly runningPromise;
+    private getData;
+    getMasterData(key: string): Promise<any>;
+    getMusicMeta(): Promise<any>;
+    getUserData(key: string): Promise<any>;
+    getUserDataAll(): Promise<any>;
+}
+
 interface UserDeck {
     userId: number;
     deckId: number;
@@ -81,8 +95,9 @@ declare class CardCalculator {
     private readonly eventCalculator;
     constructor(dataProvider: DataProvider);
     private getCardUnits;
-    getCardDetail(userCard: UserCard, userAreaItemLevels: AreaItemLevel[], eventId?: number): Promise<CardDetail>;
-    batchGetCardDetail(userCards: UserCard[], eventId?: number): Promise<CardDetail[]>;
+    private applyCardConfig;
+    getCardDetail(userCard: UserCard, userAreaItemLevels: AreaItemLevel[], config?: CardConfig, eventId?: number): Promise<CardDetail>;
+    batchGetCardDetail(userCards: UserCard[], config?: CardConfig, eventId?: number): Promise<CardDetail[]>;
     static isCertainlyLessThan(cardDetail0: CardDetail, cardDetail1: CardDetail): boolean;
 }
 interface CardDetail {
@@ -95,6 +110,12 @@ interface CardDetail {
     lifeSkill: number;
     eventBonus?: number;
 }
+interface CardConfig {
+    rankMax?: boolean;
+    episodeRead?: boolean;
+    masterMax?: boolean;
+    skillMax?: boolean;
+}
 
 declare class DeckService {
     private readonly dataProvider;
@@ -250,11 +271,18 @@ declare class EventCalculator {
     static getDeckEventPoint(deckCards: CardDetail[], honorBonus: number, musicMeta: MusicMeta, liveType: LiveType): number;
 }
 
+interface DeckRecommendConfig {
+    musicMeta: MusicMeta;
+    limit?: number;
+    member?: number;
+    cardConfig?: CardConfig;
+}
+
 declare class ChallengeLiveDeckRecommend {
     private readonly dataProvider;
     private readonly baseRecommend;
     constructor(dataProvider: DataProvider);
-    recommendChallengeLiveDeck(characterId: number, musicMeta: MusicMeta, limit?: number, member?: number): Promise<Array<{
+    recommendChallengeLiveDeck(characterId: number, config: DeckRecommendConfig): Promise<Array<{
         score: number;
         power: number;
         deck: UserChallengeLiveSoloDeck;
@@ -265,7 +293,7 @@ declare class EventDeckRecommend {
     private readonly dataProvider;
     private readonly baseRecommend;
     constructor(dataProvider: DataProvider);
-    recommendEventDeck(eventId: number, musicMeta: MusicMeta, liveType: LiveType, limit?: number): Promise<Array<{
+    recommendEventDeck(eventId: number, liveType: LiveType, config: DeckRecommendConfig): Promise<Array<{
         point: number;
         power: number;
         eventBonus?: number;
@@ -303,6 +331,14 @@ interface CardEpisode {
     cardEpisodePartType: string;
 }
 
+interface CardRarity {
+    cardRarityType: string;
+    seq: number;
+    maxLevel: number;
+    trainingMaxLevel?: number;
+    maxSkillLevel: number;
+}
+
 interface CharacterRank {
     id: number;
     characterId: number;
@@ -492,4 +528,4 @@ interface UserHonor {
     level: number;
 }
 
-export { AreaItemLevel, Card, CardCalculator, CardDetail, CardEpisode, CardEventCalculator, CardPowerCalculator, CardSkillCalculator, ChallengeLiveDeckRecommend, CharacterRank, DataProvider, DeckCalculator, DeckDetail, DeckService, EventCalculator, EventCard, EventDeckBonus, EventDeckRecommend, EventRarityBonusRate, GameCharacter, GameCharacterUnit, Honor, LiveCalculator, LiveDetail, LiveSkill, LiveType, MasterLesson, MusicMeta, MusicRecommend, Skill, SkillDetail, User, UserArea, UserCard, UserChallengeLiveSoloDeck, UserCharacter, UserDeck, UserHonor };
+export { AreaItemLevel, CachedDataProvider, Card, CardCalculator, CardConfig, CardDetail, CardEpisode, CardEventCalculator, CardPowerCalculator, CardRarity, CardSkillCalculator, ChallengeLiveDeckRecommend, CharacterRank, DataProvider, DeckCalculator, DeckDetail, DeckService, EventCalculator, EventCard, EventDeckBonus, EventDeckRecommend, EventRarityBonusRate, GameCharacter, GameCharacterUnit, Honor, LiveCalculator, LiveDetail, LiveSkill, LiveType, MasterLesson, MusicMeta, MusicRecommend, Skill, SkillDetail, User, UserArea, UserCard, UserChallengeLiveSoloDeck, UserCharacter, UserDeck, UserHonor };

package/dist/index.mjs

@@ -33,6 +33,45 @@ function containsAny(collection, contains) {
     return false;
 }
 
+class CachedDataProvider {
+    dataProvider;
+    constructor(dataProvider) {
+        this.dataProvider = dataProvider;
+    }
+    static globalCache = new Map();
+    instanceCache = new Map();
+    static runningPromise = new Map();
+    async getData(cache, cacheKey, promise) {
+        if (cache.has(cacheKey))
+            return cache.get(cacheKey);
+        while (CachedDataProvider.runningPromise.has(cacheKey)) {
+            await CachedDataProvider.runningPromise.get(cacheKey);
+        }
+        if (cache.has(cacheKey))
+            return cache.get(cacheKey);
+        CachedDataProvider.runningPromise.set(cacheKey, promise());
+        const data = await getOrThrow(CachedDataProvider.runningPromise, cacheKey).then(data => {
+            cache.set(cacheKey, data);
+            return data;
+        });
+        CachedDataProvider.runningPromise.delete(cacheKey);
+        return data;
+    }
+    async getMasterData(key) {
+        return await this.getData(CachedDataProvider.globalCache, key, async () => await this.dataProvider.getMasterData(key));
+    }
+    async getMusicMeta() {
+        return await this.getData(CachedDataProvider.globalCache, 'musicMeta', async () => await this.dataProvider.getMusicMeta());
+    }
+    async getUserData(key) {
+        const allData = await this.getUserDataAll();
+        return allData[key];
+    }
+    async getUserDataAll() {
+        return await this.getData(this.instanceCache, 'userData', async () => await this.dataProvider.getUserDataAll());
+    }
+}
+
 class DeckService {
     dataProvider;
     constructor(dataProvider) {
@@ -298,13 +337,40 @@ class CardCalculator {
         units.push(findOrThrow(gameCharacters, it => it.id === card.characterId).unit);
         return units;
     }
-    async getCardDetail(userCard, userAreaItemLevels, eventId = 0) {
+    async applyCardConfig(userCard, card, { rankMax = false, episodeRead = false, masterMax = false, skillMax = false }) {
+        if (!rankMax && !episodeRead && !masterMax && !skillMax)
+            return userCard;
+        const cardRarities = await this.dataProvider.getMasterData('cardRarities');
+        const cardRarity = findOrThrow(cardRarities, it => it.cardRarityType === card.cardRarityType);
+        const ret = JSON.parse(JSON.stringify(userCard));
+        if (rankMax) {
+            if (cardRarity.trainingMaxLevel !== undefined) {
+                ret.level = cardRarity.trainingMaxLevel;
+                ret.specialTrainingStatus = 'done';
+            }
+            else {
+                ret.level = cardRarity.maxLevel;
+            }
+        }
+        if (episodeRead) {
+            ret.episodes.forEach(it => { it.scenarioStatus = 'already_read'; });
+        }
+        if (masterMax) {
+            ret.masterRank = 5;
+        }
+        if (skillMax) {
+            ret.skillLevel = cardRarity.maxSkillLevel;
+        }
+        return ret;
+    }
+    async getCardDetail(userCard, userAreaItemLevels, config = {}, eventId = 0) {
         const cards = await this.dataProvider.getMasterData('cards');
         const card = findOrThrow(cards, it => it.id === userCard.cardId);
         const units = await this.getCardUnits(card);
-        const skill = await this.skillCalculator.getCardSkill(userCard, card);
-        const power = await this.powerCalculator.getCardPower(userCard, card, units, userAreaItemLevels);
-        const eventBonus = eventId === 0 ? undefined : await this.eventCalculator.getCardEventBonus(userCard, eventId);
+        const userCard0 = await this.applyCardConfig(userCard, card, config);
+        const skill = await this.skillCalculator.getCardSkill(userCard0, card);
+        const power = await this.powerCalculator.getCardPower(userCard0, card, units, userAreaItemLevels);
+        const eventBonus = eventId === 0 ? undefined : await this.eventCalculator.getCardEventBonus(userCard0, eventId);
         return {
             cardId: card.id,
             characterId: card.characterId,
@@ -316,11 +382,11 @@ class CardCalculator {
             eventBonus
         };
     }
-    async batchGetCardDetail(userCards, eventId = 0) {
+    async batchGetCardDetail(userCards, config = {}, eventId = 0) {
         const areaItemLevels = await this.dataProvider.getMasterData('areaItemLevels');
         const userAreas = await this.dataProvider.getUserData('userAreas');
         const userItemLevels = userAreas.flatMap(it => it.areaItems).map(areaItem => findOrThrow(areaItemLevels, it => it.areaItemId === areaItem.areaItemId && it.level === areaItem.level));
-        return await Promise.all(userCards.map(async (it) => await this.getCardDetail(it, userItemLevels, eventId)));
+        return await Promise.all(userCards.map(async (it) => await this.getCardDetail(it, userItemLevels, config, eventId)));
     }
     static isCertainlyLessThan(cardDetail0, cardDetail1) {
         return cardDetail0.power.isCertainlyLessThen(cardDetail1.power) &&
@@ -543,7 +609,7 @@ class BaseDeckRecommend {
     }
     static filterCard(cardDetails) {
         let afterFilter = cardDetails;
-        for (const minBonus of [65, 50, 40, 25, 15, 0]) {
+        for (const minBonus of [55, 50, 45, 40, 30, 25, 15, 5, 0]) {
             const bonusFilter = cardDetails.filter(cardDetail => !(cardDetail.eventBonus !== undefined && cardDetail.eventBonus < minBonus));
             if (this.canMakeEventDeck(bonusFilter)) {
                 afterFilter = bonusFilter;
@@ -591,8 +657,8 @@ class BaseDeckRecommend {
             throw new Error(`Cannot find deck in ${cardDetails.length} cards`);
         return ans;
     }
-    async recommendHighScoreDeck(userCards, musicMeta, scoreFunc, limit = 1, eventId = 0, isChallengeLive = false, member = 5) {
-        const cards = await this.cardCalculator.batchGetCardDetail(userCards, eventId);
+    async recommendHighScoreDeck(userCards, scoreFunc, { musicMeta, limit = 1, member = 5, cardConfig = {} }, eventId = 0, isChallengeLive = false) {
+        const cards = await this.cardCalculator.batchGetCardDetail(userCards, cardConfig, eventId);
         let cardDetails = (isChallengeLive || eventId === 0) ? cards : BaseDeckRecommend.filterCard(cards);
         cardDetails = cardDetails.sort((a, b) => a.cardId - b.cardId);
         const honorBonus = await this.deckCalculator.getHonorBonusPower();
@@ -613,12 +679,12 @@ class ChallengeLiveDeckRecommend {
         this.dataProvider = dataProvider;
         this.baseRecommend = new BaseDeckRecommend(dataProvider);
     }
-    async recommendChallengeLiveDeck(characterId, musicMeta, limit = 1, member = 5) {
+    async recommendChallengeLiveDeck(characterId, config) {
         const userCards = await this.dataProvider.getUserData('userCards');
         const cards = await this.dataProvider.getMasterData('cards');
         const characterCards = userCards
             .filter(userCard => findOrThrow(cards, it => it.id === userCard.cardId).characterId === characterId);
-        const recommend = await this.baseRecommend.recommendHighScoreDeck(characterCards, musicMeta, BaseDeckRecommend.getLiveScoreFunction(LiveType.SOLO), limit, 0, true, member);
+        const recommend = await this.baseRecommend.recommendHighScoreDeck(characterCards, BaseDeckRecommend.getLiveScoreFunction(LiveType.SOLO), config, 0, true);
         return recommend.map(it => {
             return {
                 score: it.score,
@@ -636,9 +702,9 @@ class EventDeckRecommend {
         this.dataProvider = dataProvider;
         this.baseRecommend = new BaseDeckRecommend(dataProvider);
     }
-    async recommendEventDeck(eventId, musicMeta, liveType, limit = 1) {
+    async recommendEventDeck(eventId, liveType, config) {
         const userCards = await this.dataProvider.getUserData('userCards');
-        const recommend = await this.baseRecommend.recommendHighScoreDeck(userCards, musicMeta, BaseDeckRecommend.getEventPointFunction(liveType), limit, eventId);
+        const recommend = await this.baseRecommend.recommendHighScoreDeck(userCards, BaseDeckRecommend.getEventPointFunction(liveType), config, eventId);
         return recommend.map(it => {
             return {
                 point: it.score,
@@ -682,4 +748,4 @@ class MusicRecommend {
     }
 }
 
-export { CardCalculator, CardEventCalculator, CardPowerCalculator, CardSkillCalculator, ChallengeLiveDeckRecommend, DeckCalculator, DeckService, EventCalculator, EventDeckRecommend, LiveCalculator, LiveType, MusicRecommend };
+export { CachedDataProvider, CardCalculator, CardEventCalculator, CardPowerCalculator, CardSkillCalculator, ChallengeLiveDeckRecommend, DeckCalculator, DeckService, EventCalculator, EventDeckRecommend, LiveCalculator, LiveType, MusicRecommend };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sekai-calculator",
-  "version": "0.4.4",
+  "version": "0.5.1",
   "description": "Project SEKAI Calculator for deck power, live score, event point and more.",
   "type": "module",
   "types": "dist/index.d.ts",
@@ -30,22 +30,22 @@
   },
   "license": "LGPL-2.1-or-later",
   "devDependencies": {
-    "@rollup/plugin-typescript": "^11.0.0",
-    "@types/jest": "^29.4.1",
-    "@types/node": "^18.15.3",
-    "@typescript-eslint/eslint-plugin": "^5.55.0",
-    "eslint": "^8.36.0",
-    "eslint-config-standard-with-typescript": "^34.0.0",
+    "@rollup/plugin-typescript": "^11.1.0",
+    "@types/jest": "^29.5.0",
+    "@types/node": "^18.15.11",
+    "@typescript-eslint/eslint-plugin": "^5.57.1",
+    "eslint": "^8.37.0",
+    "eslint-config-standard-with-typescript": "^34.0.1",
     "eslint-plugin-import": "^2.27.5",
-    "eslint-plugin-n": "^15.6.1",
+    "eslint-plugin-n": "^15.7.0",
     "eslint-plugin-promise": "^6.1.1",
     "jest": "^29.5.0",
-    "rollup": "^3.19.1",
-    "rollup-plugin-dts": "^5.2.0",
-    "ts-jest": "^29.0.5",
+    "rollup": "^3.20.2",
+    "rollup-plugin-dts": "^5.3.0",
+    "ts-jest": "^29.1.0",
     "ts-node": "^10.9.1",
     "tslib": "^2.5.0",
-    "typescript": "^4.9.5"
+    "typescript": "^5.0.3"
   },
   "scripts": {
     "build": "rollup -c --configPlugin typescript",