@dchighs/dc-config-mapper 0.1.4 → 0.2.1

package/dist/enums/reward-acronym.enum.d.ts

@@ -0,0 +1,29 @@
+export declare enum RewardAcronym {
+    Chest = "chest",
+    Dragon = "egg",
+    Gold = "g",
+    Gem = "c",
+    Food = "f",
+    Building = "b",
+    TerraToken = "e_token",
+    FlameToken = "f_token",
+    SeaToken = "w_token",
+    NatureToken = "p_token",
+    ElectricToken = "el_token",
+    IceToken = "i_token",
+    MetalToken = "m_token",
+    DarkToken = "d_token",
+    LightToken = "li_token",
+    WarToken = "wr_token",
+    PureToken = "pu_token",
+    LegendToken = "l_token",
+    PrimalToken = "pr_token",
+    WindToken = "wd_token",
+    TimeToken = "ti_token",
+    HappyToken = "hp_token",
+    ChaosToken = "ch_token",
+    MagicToken = "mg_token",
+    SoulToken = "so_token",
+    BeautyToken = "bt_token",
+    DreamToken = "dr_token"
+}

package/dist/enums/reward-acronym.enum.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RewardAcronym = void 0;
+var RewardAcronym;
+(function (RewardAcronym) {
+    RewardAcronym["Chest"] = "chest";
+    RewardAcronym["Dragon"] = "egg";
+    RewardAcronym["Gold"] = "g";
+    RewardAcronym["Gem"] = "c";
+    RewardAcronym["Food"] = "f";
+    RewardAcronym["Building"] = "b";
+    RewardAcronym["TerraToken"] = "e_token";
+    RewardAcronym["FlameToken"] = "f_token";
+    RewardAcronym["SeaToken"] = "w_token";
+    RewardAcronym["NatureToken"] = "p_token";
+    RewardAcronym["ElectricToken"] = "el_token";
+    RewardAcronym["IceToken"] = "i_token";
+    RewardAcronym["MetalToken"] = "m_token";
+    RewardAcronym["DarkToken"] = "d_token";
+    RewardAcronym["LightToken"] = "li_token";
+    RewardAcronym["WarToken"] = "wr_token";
+    RewardAcronym["PureToken"] = "pu_token";
+    RewardAcronym["LegendToken"] = "l_token";
+    RewardAcronym["PrimalToken"] = "pr_token";
+    RewardAcronym["WindToken"] = "wd_token";
+    RewardAcronym["TimeToken"] = "ti_token";
+    RewardAcronym["HappyToken"] = "hp_token";
+    RewardAcronym["ChaosToken"] = "ch_token";
+    RewardAcronym["MagicToken"] = "mg_token";
+    RewardAcronym["SoulToken"] = "so_token";
+    RewardAcronym["BeautyToken"] = "bt_token";
+    RewardAcronym["DreamToken"] = "dr_token";
+})(RewardAcronym || (exports.RewardAcronym = RewardAcronym = {}));

package/dist/enums/reward-type.enum.d.ts

@@ -0,0 +1,10 @@
+export declare enum RewardType {
+    Chest = "chest",
+    Dragon = "dragon",
+    Building = "building",
+    Gold = "gold",
+    Gem = "gem",
+    Food = "food",
+    HabitatToken = "habitat_token",
+    IslandCoin = "island_coin"
+}

package/dist/enums/reward-type.enum.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RewardType = void 0;
+var RewardType;
+(function (RewardType) {
+    RewardType["Chest"] = "chest";
+    RewardType["Dragon"] = "dragon";
+    RewardType["Building"] = "building";
+    RewardType["Gold"] = "gold";
+    RewardType["Gem"] = "gem";
+    RewardType["Food"] = "food";
+    RewardType["HabitatToken"] = "habitat_token";
+    RewardType["IslandCoin"] = "island_coin";
+})(RewardType || (exports.RewardType = RewardType = {}));

package/dist/mappers/chest.mapper.d.ts

@@ -12,13 +12,13 @@ export declare class ChestsMapper {
             id: number;
             reward: {
                 resource: {
-                    type: import("../enums/reward-resource-type.enum").RewardResourceType;
-                    amount: number;
-                    element?: undefined;
-                } | {
-                    type: import("../enums/reward-resource-type.enum").RewardResourceType;
-                    element: import("@dchighs/dc-core").DragonElement;
-                    amount: never;
+                    type: import("../enums/reward-type.enum").RewardType;
+                    element?: import("@dchighs/dc-core").DragonElement;
+                    amount?: number;
+                    chest_id?: number;
+                    dragon_id?: number;
+                    dragon_ids?: number[];
+                    building_id?: number;
                 } | undefined;
                 building_ids: number[] | undefined;
                 eggs_ids: number[] | undefined;

package/dist/mappers/heroic-races.mapper.d.ts

@@ -32,15 +32,15 @@ export declare class HeroicRacesMapper {
         rewards: {
             id: number;
             positions: number[];
-            rewards: ({
-                type: import("../enums/reward-resource-type.enum").RewardResourceType;
-                amount: number;
-                dragon_ids?: undefined;
-            } | {
-                type: import("../enums/reward-resource-type.enum").RewardResourceType;
-                dragon_ids: number[];
-                amount?: undefined;
-            })[];
+            reward: {
+                type: import("../enums/reward-type.enum").RewardType;
+                element?: import("@dchighs/dc-core").DragonElement;
+                amount?: number;
+                chest_id?: number;
+                dragon_id?: number;
+                dragon_ids?: number[];
+                building_id?: number;
+            }[];
         }[];
         encounters: {
             id: number;

package/dist/mappers/index.d.ts

@@ -3,3 +3,4 @@ export * from "./items.mapper";
 export * from "./skills.mapper";
 export * from "./heroic-races.mapper";
 export * from "./maze-islands.mapper";
+export * from "./tower-islands.mapper";

package/dist/mappers/index.js

@@ -19,3 +19,4 @@ __exportStar(require("./items.mapper"), exports);
 __exportStar(require("./skills.mapper"), exports);
 __exportStar(require("./heroic-races.mapper"), exports);
 __exportStar(require("./maze-islands.mapper"), exports);
+__exportStar(require("./tower-islands.mapper"), exports);

package/dist/mappers/maze-islands.mapper.d.ts

@@ -86,6 +86,7 @@ export declare class MazeIslandsMapper {
         islands: import("@dchighs/dc-localization/dist/types").Translated<{
             id: number;
             name: string;
+            name_key: string;
             availability: {
                 from: string;
                 to: string;
@@ -105,22 +106,15 @@ export declare class MazeIslandsMapper {
         nodes: import("@dchighs/dc-localization/dist/types").Translated<{
             id: number;
             cost: number;
-            rewards: ({
-                type: import("../enums/reward-resource-type.enum").RewardResourceType;
-                amount: number;
-                chest_id?: undefined;
-                building_id?: undefined;
-            } | {
-                type: import("../enums/reward-resource-type.enum").RewardResourceType;
-                chest_id: number;
-                amount?: undefined;
-                building_id?: undefined;
-            } | {
-                type: import("../enums/reward-resource-type.enum").RewardResourceType;
-                building_id: number;
-                amount?: undefined;
-                chest_id?: undefined;
-            })[] | undefined;
+            rewards: {
+                type: import("../enums/reward-type.enum").RewardType;
+                element?: import("@dchighs/dc-core").DragonElement;
+                amount?: number;
+                chest_id?: number;
+                dragon_id?: number;
+                dragon_ids?: number[];
+                building_id?: number;
+            }[] | undefined;
             is_highlighted: boolean | undefined;
             key_path_id: number | undefined;
             encounter_id: number | undefined;

package/dist/mappers/tower-islands.mapper.d.ts

@@ -0,0 +1,102 @@
+import { Localization } from "@dchighs/dc-localization";
+import { GameConfigDto } from "@dchighs/dc-config";
+export type TowerIslandsDto = GameConfigDto["game_data"]["config"]["tower_island"];
+export declare class TowerIslandsMapper {
+    readonly localization: Localization;
+    constructor(localization: Localization);
+    map(data: TowerIslandsDto): {
+        islands: import("@dchighs/dc-localization/dist/types").Translated<{
+            id: number;
+            name_key: string;
+            availability: {
+                from: string;
+                to: string;
+            };
+            initial_square_id: number;
+            pool: {
+                size: number;
+                time: number;
+            };
+            initial_points: number;
+            currency_id: number;
+            min_level: number;
+            tower_size: number[];
+            zip_file_name: string;
+            sound_tag: string;
+            max_die_roll: number;
+            help_view_id: number;
+            square_ids: number[];
+            floor_ids: number[];
+        }>[];
+        floors: import("@dchighs/dc-localization/dist/types").Translated<{
+            id: number;
+            y: number;
+            x_flip: boolean;
+            floor_image: string;
+            area: number;
+            roll_die_price: number;
+        }>[];
+        squares: import("@dchighs/dc-localization/dist/types").Translated<{
+            id: number;
+            type: string;
+            is_highlight: boolean;
+            x: number;
+            y: number;
+            ixy: string;
+            rewards: {
+                type: import("../enums/reward-type.enum").RewardType;
+                element?: import("@dchighs/dc-core").DragonElement;
+                amount?: number;
+                chest_id?: number;
+                dragon_id?: number;
+                dragon_ids?: number[];
+                building_id?: number;
+            }[] | null;
+            wall: string | undefined;
+            catapult_destination_square_id: number | undefined;
+            piece_reward_id: number | undefined;
+        }>[];
+        rewards: import("@dchighs/dc-localization/dist/types").Translated<{
+            id: number;
+            dragon_id: number;
+            last_piece_cost: number;
+            pieces_count: number;
+            show_new_badge: boolean;
+            area: number;
+        }>[];
+        happy_hours: import("@dchighs/dc-localization/dist/types").Translated<{
+            id: number;
+            availability: {
+                from: number;
+                to: number;
+            };
+            island_id: number;
+            discount: number;
+        }>[];
+        parameters: import("@dchighs/dc-localization/dist/types").Translated<{
+            id: number;
+            name: string;
+            value: any;
+        }>[];
+        currencies: import("@dchighs/dc-localization/dist/types").Translated<{
+            id: number;
+            tid_name: string;
+            actions: Array<number>;
+        }>[];
+        actions: import("@dchighs/dc-localization/dist/types").Translated<{
+            id: number;
+            type: string;
+            tid_name: string;
+            image: string;
+            pool_percent: number;
+            max_points: number;
+            extra_parameters?: {
+                max_time?: number;
+                cooldown?: number;
+                max_control_level?: number;
+                max_production?: number;
+                max_level?: number;
+            };
+        }>[];
+    };
+}

package/dist/mappers/tower-islands.mapper.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TowerIslandsMapper = void 0;
+const island_schema_1 = require("../schemas/islands/tower-islands/island.schema");
+const square_schema_1 = require("../schemas/islands/tower-islands/square.schema");
+const floor_schema_1 = require("../schemas/islands/tower-islands/floor.schema");
+const reward_schema_1 = require("../schemas/islands/tower-islands/reward.schema");
+class TowerIslandsMapper {
+    constructor(localization) {
+        this.localization = localization;
+    }
+    map(data) {
+        return {
+            islands: data.islands.map(island => {
+                const squareIds = data.squares.filter(square => square.island_id === island.id).map(square => square.id);
+                const floorIds = data.floors.filter(floor => floor.island_id === island.id).map(floor => floor.id);
+                return this.localization.translate(island_schema_1.towerIslandSchema.parse({
+                    ...island,
+                    square_ids: squareIds,
+                    floor_ids: floorIds
+                }));
+            }),
+            floors: data.floors.map(floor => this.localization.translate(floor_schema_1.towerIslandsFloorSchema.parse(floor))),
+            squares: data.squares.map(square => this.localization.translate(square_schema_1.towerIslandsSquareSchema.parse(square))),
+            rewards: data.rewards.map(reward => this.localization.translate(reward_schema_1.towerIslandsRewardSchema.parse(reward))),
+            happy_hours: data.happy_hours.map(happyHour => this.localization.translate(happyHour)),
+            parameters: data.parameters.map(parameter => this.localization.translate(parameter)),
+            currencies: data.currencies.map(currency => this.localization.translate(currency)),
+            actions: data.actions.map(action => this.localization.translate(action)),
+        };
+    }
+}
+exports.TowerIslandsMapper = TowerIslandsMapper;

package/dist/schemas/chests/chest.schema.d.ts

@@ -49,13 +49,13 @@ export declare const chestSchema: z.ZodPipe<z.ZodObject<{
         id: number;
         reward: {
             resource: {
-                type: import("../../enums/reward-resource-type.enum").RewardResourceType;
-                amount: number;
-                element?: undefined;
-            } | {
-                type: import("../../enums/reward-resource-type.enum").RewardResourceType;
-                element: import("@dchighs/dc-core").DragonElement;
-                amount: never;
+                type: import("../../enums/reward-type.enum").RewardType;
+                element?: import("@dchighs/dc-core").DragonElement;
+                amount?: number;
+                chest_id?: number;
+                dragon_id?: number;
+                dragon_ids?: number[];
+                building_id?: number;
             } | undefined;
             building_ids: number[] | undefined;
             eggs_ids: number[] | undefined;
@@ -137,13 +137,13 @@ export declare const chestSchema: z.ZodPipe<z.ZodObject<{
         id: number;
         reward: {
             resource: {
-                type: import("../../enums/reward-resource-type.enum").RewardResourceType;
-                amount: number;
-                element?: undefined;
-            } | {
-                type: import("../../enums/reward-resource-type.enum").RewardResourceType;
-                element: import("@dchighs/dc-core").DragonElement;
-                amount: never;
+                type: import("../../enums/reward-type.enum").RewardType;
+                element?: import("@dchighs/dc-core").DragonElement;
+                amount?: number;
+                chest_id?: number;
+                dragon_id?: number;
+                dragon_ids?: number[];
+                building_id?: number;
             } | undefined;
             building_ids: number[] | undefined;
             eggs_ids: number[] | undefined;
@@ -181,13 +181,13 @@ export declare const chestSchema: z.ZodPipe<z.ZodObject<{
         id: number;
         reward: {
             resource: {
-                type: import("../../enums/reward-resource-type.enum").RewardResourceType;
-                amount: number;
-                element?: undefined;
-            } | {
-                type: import("../../enums/reward-resource-type.enum").RewardResourceType;
-                element: import("@dchighs/dc-core").DragonElement;
-                amount: never;
+                type: import("../../enums/reward-type.enum").RewardType;
+                element?: import("@dchighs/dc-core").DragonElement;
+                amount?: number;
+                chest_id?: number;
+                dragon_id?: number;
+                dragon_ids?: number[];
+                building_id?: number;
             } | undefined;
             building_ids: number[] | undefined;
             eggs_ids: number[] | undefined;

package/dist/schemas/chests/reward.schema.d.ts

@@ -1,5 +1,4 @@
 import { z } from "zod";
-import { RewardResourceType } from "../../enums/reward-resource-type.enum";
 export declare const chestRewardSchema: z.ZodPipe<z.ZodObject<{
     id: z.ZodNumber;
     reward: z.ZodObject<{
@@ -47,13 +46,13 @@ export declare const chestRewardSchema: z.ZodPipe<z.ZodObject<{
     id: number;
     reward: {
         resource: {
-            type: RewardResourceType;
-            amount: number;
-            element?: undefined;
-        } | {
-            type: RewardResourceType;
-            element: import("@dchighs/dc-core").DragonElement;
-            amount: never;
+            type: import("../../enums/reward-type.enum").RewardType;
+            element?: import("@dchighs/dc-core").DragonElement;
+            amount?: number;
+            chest_id?: number;
+            dragon_id?: number;
+            dragon_ids?: number[];
+            building_id?: number;
         } | undefined;
         building_ids: number[] | undefined;
         eggs_ids: number[] | undefined;

package/dist/schemas/chests/reward.schema.js

@@ -2,53 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.chestRewardSchema = void 0;
 const zod_1 = require("zod");
-const reward_resource_type_enum_1 = require("../../enums/reward-resource-type.enum");
-const element_map_util_1 = require("../../utils/element-map.util");
-function processReward(rewardResource) {
-    if (!rewardResource) {
-        return;
-    }
-    if (rewardResource === null || rewardResource === void 0 ? void 0 : rewardResource.c) {
-        return {
-            type: reward_resource_type_enum_1.RewardResourceType.Gem,
-            amount: rewardResource.c,
-        };
-    }
-    if (rewardResource === null || rewardResource === void 0 ? void 0 : rewardResource.f) {
-        return {
-            type: reward_resource_type_enum_1.RewardResourceType.Food,
-            amount: rewardResource.f,
-        };
-    }
-    if (rewardResource === null || rewardResource === void 0 ? void 0 : rewardResource.g) {
-        return {
-            type: reward_resource_type_enum_1.RewardResourceType.Gold,
-            amount: rewardResource.g,
-        };
-    }
-    const tokenKey = Object.keys(rewardResource).find((key) => key.endsWith("_token"));
-    if (tokenKey) {
-        const elementAcronym = tokenKey.replace("_token", "");
-        return {
-            type: reward_resource_type_enum_1.RewardResourceType.HabitatToken,
-            element: element_map_util_1.elementMap[elementAcronym],
-            amount: rewardResource[tokenKey],
-        };
-    }
-    if (rewardResource === null || rewardResource === void 0 ? void 0 : rewardResource.ep) {
-        return {
-            type: reward_resource_type_enum_1.RewardResourceType.IslandCoin,
-            amount: rewardResource.ep,
-        };
-    }
-    if (rewardResource === null || rewardResource === void 0 ? void 0 : rewardResource.x) {
-        return {
-            type: reward_resource_type_enum_1.RewardResourceType.Xp,
-            amount: rewardResource.x,
-        };
-    }
-    throw new Error(`Invalid reward resource: ${JSON.stringify(rewardResource)}`);
-}
+const utils_1 = require("../../utils");
 exports.chestRewardSchema = zod_1.z.object({
     id: zod_1.z.number(),
     reward: zod_1.z.object({
@@ -94,7 +48,7 @@ exports.chestRewardSchema = zod_1.z.object({
     weight: zod_1.z.number(),
 }).strict().transform((data) => {
     const reward = {
-        resource: data.reward.resource ? processReward(data.reward.resource) : undefined,
+        resource: data.reward.resource ? (0, utils_1.processRewards)([data.reward.resource])[0] : undefined,
         building_ids: data.reward.buildings,
         eggs_ids: data.reward.eggs,
         seeds: data.reward.seeds,

package/dist/schemas/islands/heroic-races/reward.schema.d.ts

@@ -1,5 +1,4 @@
 import { z } from "zod";
-import { RewardResourceType } from "../../../enums/reward-resource-type.enum";
 export declare const heroicRacesRewardSchema: z.ZodPipe<z.ZodObject<{
     id: z.ZodNumber;
     positions: z.ZodArray<z.ZodNumber>;
@@ -10,15 +9,15 @@ export declare const heroicRacesRewardSchema: z.ZodPipe<z.ZodObject<{
 }, z.core.$strict>, z.ZodTransform<{
     id: number;
     positions: number[];
-    rewards: ({
-        type: RewardResourceType;
-        amount: number;
-        dragon_ids?: undefined;
-    } | {
-        type: RewardResourceType;
-        dragon_ids: number[];
-        amount?: undefined;
-    })[];
+    reward: {
+        type: import("../../../enums/reward-type.enum").RewardType;
+        element?: import("@dchighs/dc-core").DragonElement;
+        amount?: number;
+        chest_id?: number;
+        dragon_id?: number;
+        dragon_ids?: number[];
+        building_id?: number;
+    }[];
 }, {
     id: number;
     positions: number[];

package/dist/schemas/islands/heroic-races/reward.schema.js

@@ -2,22 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.heroicRacesRewardSchema = void 0;
 const zod_1 = require("zod");
-const reward_resource_type_enum_1 = require("../../../enums/reward-resource-type.enum");
-function processReward(reward) {
-    if (reward.c) {
-        return {
-            type: reward_resource_type_enum_1.RewardResourceType.Gem,
-            amount: reward.c,
-        };
-    }
-    if (reward.egg) {
-        return {
-            type: reward_resource_type_enum_1.RewardResourceType.Dragon,
-            dragon_ids: reward.egg,
-        };
-    }
-    throw new Error(`Invalid reward: ${JSON.stringify(reward)}`);
-}
+const utils_1 = require("../../../utils");
 exports.heroicRacesRewardSchema = zod_1.z.object({
     id: zod_1.z.number(),
     positions: zod_1.z.array(zod_1.z.number()),
@@ -29,6 +14,6 @@ exports.heroicRacesRewardSchema = zod_1.z.object({
     return {
         id: data.id,
         positions: data.positions,
-        rewards: data.rewards.map(processReward),
+        reward: (0, utils_1.processRewards)(data.rewards),
     };
 });

package/dist/schemas/islands/maze-islands/island.schema.d.ts

@@ -37,6 +37,7 @@ export declare const mazeIslandSchema: z.ZodPipe<z.ZodObject<{
 }, z.core.$strict>, z.ZodTransform<{
     id: number;
     name: string;
+    name_key: string;
     availability: {
         from: string;
         to: string;

package/dist/schemas/islands/maze-islands/island.schema.js

@@ -45,6 +45,7 @@ exports.mazeIslandSchema = zod_1.z.object({
     return {
         id: data.id,
         name: data.name,
+        name_key: data.tid_name,
         availability: {
             from: new Date(data.availability.from * 1000).toISOString(),
             to: new Date(data.availability.to * 1000).toISOString(),

package/dist/schemas/islands/maze-islands/node.schema.d.ts

@@ -1,5 +1,4 @@
 import { z } from "zod";
-import { RewardResourceType } from "../../../enums/reward-resource-type.enum";
 export declare const mazeIslandsNodeSchema: z.ZodPipe<z.ZodObject<{
     id: z.ZodNumber;
     position: z.ZodArray<z.ZodNumber>;
@@ -22,22 +21,15 @@ export declare const mazeIslandsNodeSchema: z.ZodPipe<z.ZodObject<{
 }, z.core.$strict>, z.ZodTransform<{
     id: number;
     cost: number;
-    rewards: ({
-        type: RewardResourceType;
-        amount: number;
-        chest_id?: undefined;
-        building_id?: undefined;
-    } | {
-        type: RewardResourceType;
-        chest_id: number;
-        amount?: undefined;
-        building_id?: undefined;
-    } | {
-        type: RewardResourceType;
-        building_id: number;
-        amount?: undefined;
-        chest_id?: undefined;
-    })[] | undefined;
+    rewards: {
+        type: import("../../../enums/reward-type.enum").RewardType;
+        element?: import("@dchighs/dc-core").DragonElement;
+        amount?: number;
+        chest_id?: number;
+        dragon_id?: number;
+        dragon_ids?: number[];
+        building_id?: number;
+    }[] | undefined;
     is_highlighted: boolean | undefined;
     key_path_id: number | undefined;
     encounter_id: number | undefined;

package/dist/schemas/islands/maze-islands/node.schema.js

@@ -2,34 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.mazeIslandsNodeSchema = void 0;
 const zod_1 = require("zod");
-const reward_resource_type_enum_1 = require("../../../enums/reward-resource-type.enum");
-function processReward(reward) {
-    if (reward === null || reward === void 0 ? void 0 : reward.f) {
-        return {
-            type: reward_resource_type_enum_1.RewardResourceType.Food,
-            amount: reward.f,
-        };
-    }
-    if (reward === null || reward === void 0 ? void 0 : reward.g) {
-        return {
-            type: reward_resource_type_enum_1.RewardResourceType.Gold,
-            amount: reward.g,
-        };
-    }
-    if (reward === null || reward === void 0 ? void 0 : reward.chest) {
-        return {
-            type: reward_resource_type_enum_1.RewardResourceType.Chest,
-            chest_id: reward.chest,
-        };
-    }
-    if (reward === null || reward === void 0 ? void 0 : reward.b) {
-        return {
-            type: reward_resource_type_enum_1.RewardResourceType.Building,
-            building_id: reward.b,
-        };
-    }
-    throw new Error(`Invalid reward: ${JSON.stringify(reward)}`);
-}
+const utils_1 = require("../../../utils");
 exports.mazeIslandsNodeSchema = zod_1.z.object({
     id: zod_1.z.number(),
     position: zod_1.z.array(zod_1.z.number()).length(2),
@@ -54,7 +27,7 @@ exports.mazeIslandsNodeSchema = zod_1.z.object({
     return {
         id: data.id,
         cost: (_b = (_a = data.cost) === null || _a === void 0 ? void 0 : _a.ep) !== null && _b !== void 0 ? _b : 0,
-        rewards: data.reward ? data.reward.map(processReward) : undefined,
+        rewards: data.reward ? (0, utils_1.processRewards)(data.reward) : undefined,
         is_highlighted: data.highlighted,
         key_path_id: data.key,
         encounter_id: data.encounter,