UPDATE: monster bar

src/helper/connect.ts

@@ -1,9 +1,9 @@
 "use client"
-import { SendDataThroughProxy, SendDataToServer } from "@/lib/api"
+import { SendDataThroughProxy, SendDataToServer } from "@/lib/api/api"
 import useConnectStore from "@/stores/connectStore"
 import useUserDataStore from "@/stores/userDataStore"
 import { converterToFreeSRJson } from "./converterToFreeSRJson"
-import { psResponseSchema } from "@/zod"
+import { pSResponseSchema } from "@/zod"
 
 export const connectToPS = async (): Promise<{ success: boolean, message: string }> => {
     const {
@@ -27,7 +27,7 @@ export const connectToPS = async (): Promise<{ success: boolean, message: string
         } else if (response.error) {
             return { success: false, message: response.error }
         } else {
-            const parsed = psResponseSchema.safeParse(response.data)
+            const parsed = pSResponseSchema.safeParse(response.data)
             if (!parsed.success) {
                 return { success: false, message: "Invalid response schema" }
             }
@@ -53,8 +53,8 @@ export const syncDataToPS = async (): Promise<{ success: boolean, message: strin
         password
     } = useConnectStore.getState()
 
-    const {avatars, battle_config} = useUserDataStore.getState()
-    const data = converterToFreeSRJson(avatars, battle_config)
+    const {avatars, battle_type, moc_config, pf_config, as_config, ce_config} = useUserDataStore.getState()
+    const data = converterToFreeSRJson(avatars, battle_type, moc_config, pf_config, as_config, ce_config)
 
     let urlQuery = serverUrl
     if (!urlQuery.startsWith("http://") && !urlQuery.startsWith("https://")) {
@@ -69,7 +69,7 @@ export const syncDataToPS = async (): Promise<{ success: boolean, message: strin
         } else if (response.error) {
             return { success: false, message: response.error }
         } else {
-            const parsed = psResponseSchema.safeParse(response.data)
+            const parsed = pSResponseSchema.safeParse(response.data)
             if (!parsed.success) {
                 return { success: false, message: "Invalid response schema" }
             }

src/helper/convertData.ts

@@ -1,4 +1,4 @@
-import { CharacterBasic, CharacterBasicRaw, LightConeBasic, LightConeBasicRaw, RelicBasic, RelicBasicEffect, RelicBasicRaw } from "@/types";
+import { CharacterBasic, CharacterBasicRaw, EventBasic, EventBasicRaw, LightConeBasic, LightConeBasicRaw, MonsterBasic, MonsterBasicRaw, RelicBasic, RelicBasicEffect, RelicBasicRaw } from "@/types";
 
 export function convertRelicSet(id: string, item: RelicBasicRaw): RelicBasic {
     let lang = new Map<string, string>([
@@ -86,4 +86,43 @@ export function convertAvatar(id: string, item: CharacterBasicRaw): CharacterBas
     return result;
 }
 
+export function convertEvent(id: string, item: EventBasicRaw): EventBasic {
+    let lang = new Map<string, string>([
+        ['en', item.en],
+        ['kr', item.kr],
+        ['cn', item.cn],
+        ['jp', item.jp]
+    ]);
+    const result: EventBasic = {
+        lang: lang,
+        id: id,
+        begin: item.begin,
+        end: item.end,
+        live_begin: item.live_begin,
+        live_end: item.live_end,
+        param: item.param,
+    };
 
+    return result;
+}
+
+export function convertMonster(id: string, item: MonsterBasicRaw): MonsterBasic {
+    let lang = new Map<string, string>([
+        ['en', item.en],
+        ['kr', item.kr],
+        ['cn', item.cn],
+        ['jp', item.jp]
+    ]);
+    const result: MonsterBasic = {
+        id: id,
+        rank: item.rank,
+        camp: item.camp,
+        icon: item.icon,
+        child: item.child,
+        weak: item.weak,
+        desc: item.desc,
+        lang: lang
+    };
+
+    return result;
+}

src/helper/converterToFreeSRJson.ts

@@ -1,18 +1,69 @@
-import { AvatarJson, AvatarStore, BattleConfigJson, BattleConfigStore, FreeSRJson, LightconeJson, RelicJson } from "@/types";
-import useUserDataStore from "@/stores/userDataStore";
+import { ASConfigStore, AvatarJson, AvatarStore, BattleConfigJson, CEConfigStore, FreeSRJson, LightconeJson, MOCConfigStore, PFConfigStore, RelicJson } from "@/types";
 
-export function converterToFreeSRJson(avatars: Record<string, AvatarStore>, battle_config: BattleConfigStore): FreeSRJson {
+
+export function converterToFreeSRJson(
+    avatars: Record<string, AvatarStore>,
+    battle_type: string,
+    moc_config: MOCConfigStore,
+    pf_config: PFConfigStore,
+    as_config: ASConfigStore,
+    ce_config: CEConfigStore,
+): FreeSRJson {
     const lightcones: LightconeJson[] = []
     const relics: RelicJson[] = []
-    const battleJson: BattleConfigJson = {
-        battle_type: battle_config.battle_type,
-        blessings: battle_config.blessings,
-        custom_stats: battle_config.custom_stats,
-        cycle_count: battle_config.cycle_count,
-        stage_id: battle_config.stage_id,
-        path_resonance_id: battle_config.path_resonance_id,
-        monsters: battle_config.monsters,
+    let battleJson: BattleConfigJson
+    if (battle_type === "MOC") {
+        battleJson = {
+            battle_type: battle_type,
+            blessings: moc_config.blessings,
+            custom_stats: [],
+            cycle_count: moc_config.cycle_count,
+            stage_id: moc_config.stage_id,
+            path_resonance_id: 0,
+            monsters: moc_config.monsters,
+        }
+    } else if (battle_type === "PF") {
+        battleJson = {
+            battle_type: battle_type,
+            blessings: pf_config.blessings,
+            custom_stats: [],
+            cycle_count: pf_config.cycle_count,
+            stage_id: pf_config.stage_id,
+            path_resonance_id: 0,
+            monsters: pf_config.monsters,
+        }
+    } else if (battle_type === "AS") {
+        battleJson = {
+            battle_type: battle_type,
+            blessings: as_config.blessings,
+            custom_stats: [],
+            cycle_count: as_config.cycle_count,
+            stage_id: as_config.stage_id,
+            path_resonance_id: 0,
+            monsters: as_config.monsters,
+        }
+    } else if (battle_type === "CE") {
+        battleJson = {
+            battle_type: battle_type,
+            blessings: ce_config.blessings,
+            custom_stats: [],
+            cycle_count: ce_config.cycle_count,
+            stage_id: ce_config.stage_id,
+            path_resonance_id: 0,
+            monsters: ce_config.monsters,
+        }
+    } else {
+        battleJson = {
+            battle_type: battle_type,
+            blessings: [],
+            custom_stats: [],
+            cycle_count: 0,
+            stage_id: 0,
+            path_resonance_id: 0,
+            monsters: [],
+        }
     }
+
     const avatarsJson: { [key: string]: AvatarJson } = {}
     let internalUidLightcone = 0
     let internalUidRelic = 0

src/helper/getName.ts

@@ -1,5 +1,5 @@
 import { listCurrentLanguage } from "@/lib/constant";
-import { CharacterBasic, LightConeBasic } from "@/types";
+import { CharacterBasic, EventBasic, LightConeBasic, MonsterBasic } from "@/types";
 
 
 export function getNameChar(locale: string, data: CharacterBasic | undefined): string {
@@ -22,7 +22,7 @@ export function getNameChar(locale: string, data: CharacterBasic | undefined): s
     return text
 }
 
-export function getNameLightcone(locale: string, data: LightConeBasic | undefined): string {
+export function getLocaleName(locale: string, data: LightConeBasic | EventBasic | MonsterBasic | undefined): string {
     if (!data) {
         return ""
     }