@dchighs/dc-config-mapper 0.5.7 → 0.5.9

package/README.md

@@ -29,9 +29,9 @@ import { ChestsMapper } from "@dchighs/dc-config-mapper"
 import { Localization } from "@dchighs/dc-localization"
 
 ;(async () => {
-	const userId = process.env.USER_ID
-	const authToken = process.env.AUTH_TOKEN
-	const url = process.env.URL
+	const userId = process.env.GAME_GAME_USER_ID
+	const authToken = process.env.GAME_GAME_AUTH_TOKEN
+	const url = process.env.GAME_CONFIG_URL
 
 	const config = await Config.create({
 		userId: userId,

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

@@ -28,5 +28,9 @@ export declare enum RewardAcronym {
     DreamToken = "dr_token",
     EventPoints = "ep",
     Seeds = "seeds",
-    RunnerIslandEnergy = "en_runner"
+    RunnerIslandEnergy = "en_runner",
+    PetFoodPackSmall = "pet_food_pack.s",
+    PetFoodPackMedium = "pet_food_pack.m",
+    PetFoodPackLarge = "pet_food_pack.l",
+    PetFoodPackExtraLarge = "pet_food_pack.xl"
 }

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

@@ -33,4 +33,8 @@ var RewardAcronym;
     RewardAcronym["EventPoints"] = "ep";
     RewardAcronym["Seeds"] = "seeds";
     RewardAcronym["RunnerIslandEnergy"] = "en_runner";
+    RewardAcronym["PetFoodPackSmall"] = "pet_food_pack.s";
+    RewardAcronym["PetFoodPackMedium"] = "pet_food_pack.m";
+    RewardAcronym["PetFoodPackLarge"] = "pet_food_pack.l";
+    RewardAcronym["PetFoodPackExtraLarge"] = "pet_food_pack.xl";
 })(RewardAcronym || (exports.RewardAcronym = RewardAcronym = {}));

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

@@ -9,5 +9,7 @@ export declare enum RewardType {
     IslandCoin = "island_coin",
     EventPoints = "event_points",
     DragonOrbs = "dragon_orbs",
-    RunnerIslandEnergy = "runner_island_energy"
+    RunnerIslandEnergy = "runner_island_energy",
+    PetFoodPack = "pet_food_pack",
+    AlbumPackAces = "album_pack_aces"
 }

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

@@ -14,4 +14,6 @@ var RewardType;
     RewardType["EventPoints"] = "event_points";
     RewardType["DragonOrbs"] = "dragon_orbs";
     RewardType["RunnerIslandEnergy"] = "runner_island_energy";
+    RewardType["PetFoodPack"] = "pet_food_pack";
+    RewardType["AlbumPackAces"] = "album_pack_aces";
 })(RewardType || (exports.RewardType = RewardType = {}));

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

@@ -20,6 +20,7 @@ export declare class ChestsMapper {
                     dragon_ids?: number[];
                     building_id?: number;
                     orb_dragon_id?: number;
+                    size?: string;
                 } | undefined;
                 building_ids: number[] | undefined;
                 eggs_ids: number[] | undefined;

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

@@ -41,6 +41,7 @@ export declare class HeroicRacesMapper {
                 dragon_ids?: number[];
                 building_id?: number;
                 orb_dragon_id?: number;
+                size?: string;
             }[];
         }[];
         encounters: {

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

@@ -114,6 +114,7 @@ export declare class MazeIslandsMapper {
                 dragon_ids?: number[];
                 building_id?: number;
                 orb_dragon_id?: number;
+                size?: string;
             }[] | undefined;
             is_highlighted: boolean | undefined;
             key_path_id: number | undefined;

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

@@ -91,6 +91,7 @@ export declare class RunnerIslandsMapper {
                 dragon_ids?: number[];
                 building_id?: number;
                 orb_dragon_id?: number;
+                size?: string;
             }[];
             type_id: number;
             double_with_video_ad: boolean | undefined;

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

@@ -56,6 +56,7 @@ export declare class TowerIslandsMapper {
                 dragon_ids?: number[];
                 building_id?: number;
                 orb_dragon_id?: number;
+                size?: string;
             }[] | null;
             wall: string | undefined;
             catapult_destination_square_id: number | undefined;

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

@@ -57,6 +57,7 @@ export declare const chestSchema: z.ZodPipe<z.ZodObject<{
                 dragon_ids?: number[];
                 building_id?: number;
                 orb_dragon_id?: number;
+                size?: string;
             } | undefined;
             building_ids: number[] | undefined;
             eggs_ids: number[] | undefined;
@@ -146,6 +147,7 @@ export declare const chestSchema: z.ZodPipe<z.ZodObject<{
                 dragon_ids?: number[];
                 building_id?: number;
                 orb_dragon_id?: number;
+                size?: string;
             } | undefined;
             building_ids: number[] | undefined;
             eggs_ids: number[] | undefined;
@@ -191,6 +193,7 @@ export declare const chestSchema: z.ZodPipe<z.ZodObject<{
                 dragon_ids?: number[];
                 building_id?: number;
                 orb_dragon_id?: number;
+                size?: string;
             } | undefined;
             building_ids: number[] | undefined;
             eggs_ids: number[] | undefined;

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

@@ -54,6 +54,7 @@ export declare const chestRewardSchema: z.ZodPipe<z.ZodObject<{
             dragon_ids?: number[];
             building_id?: number;
             orb_dragon_id?: number;
+            size?: string;
         } | undefined;
         building_ids: number[] | undefined;
         eggs_ids: number[] | undefined;

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

@@ -18,6 +18,7 @@ export declare const heroicRacesRewardSchema: z.ZodPipe<z.ZodObject<{
         dragon_ids?: number[];
         building_id?: number;
         orb_dragon_id?: number;
+        size?: string;
     }[];
 }, {
     id: number;

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

@@ -8,7 +8,7 @@ export declare const mazeIslandsNodeSchema: z.ZodPipe<z.ZodObject<{
     reward_id: z.ZodOptional<z.ZodNumber>;
     reward: z.ZodOptional<z.ZodArray<z.ZodObject<{
         chest: z.ZodOptional<z.ZodNumber>;
-        b: z.ZodOptional<z.ZodNumber>;
+        b: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodArray<z.ZodNumber>]>>;
         f: z.ZodOptional<z.ZodNumber>;
         g: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>>>;
@@ -30,6 +30,7 @@ export declare const mazeIslandsNodeSchema: z.ZodPipe<z.ZodObject<{
         dragon_ids?: number[];
         building_id?: number;
         orb_dragon_id?: number;
+        size?: string;
     }[] | undefined;
     is_highlighted: boolean | undefined;
     key_path_id: number | undefined;
@@ -44,7 +45,7 @@ export declare const mazeIslandsNodeSchema: z.ZodPipe<z.ZodObject<{
     reward_id?: number | undefined;
     reward?: {
         chest?: number | undefined;
-        b?: number | undefined;
+        b?: number | number[] | undefined;
         f?: number | undefined;
         g?: number | undefined;
     }[] | undefined;

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

@@ -12,7 +12,7 @@ exports.mazeIslandsNodeSchema = zod_1.z.object({
     reward_id: zod_1.z.number().optional(),
     reward: zod_1.z.array(zod_1.z.object({
         chest: zod_1.z.number().optional(),
-        b: zod_1.z.number().optional(),
+        b: zod_1.z.union([zod_1.z.number(), zod_1.z.array(zod_1.z.number())]).optional(),
         f: zod_1.z.number().optional(),
         g: zod_1.z.number().optional(),
     })).optional(),

package/dist/schemas/islands/runner-islands/reward.schema.d.ts

@@ -43,6 +43,7 @@ export declare const runnerIslandsRewardSchema: z.ZodPipe<z.ZodObject<{
         dragon_ids?: number[];
         building_id?: number;
         orb_dragon_id?: number;
+        size?: string;
     }[];
     type_id: number;
     double_with_video_ad: boolean | undefined;

package/dist/schemas/islands/tower-islands/square.schema.d.ts

@@ -30,6 +30,7 @@ export declare const towerIslandsSquareSchema: z.ZodPipe<z.ZodObject<{
         dragon_ids?: number[];
         building_id?: number;
         orb_dragon_id?: number;
+        size?: string;
     }[] | null;
     wall: string | undefined;
     catapult_destination_square_id: number | undefined;

package/dist/utils/is-blank-object.d.ts

@@ -0,0 +1 @@
+export declare function isBlankObject<T extends Record<string, any>>(object: T): boolean;

package/dist/utils/is-blank-object.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isBlankObject = isBlankObject;
+function isBlankObject(object) {
+    return Object.keys(object).length === 0;
+}

package/dist/utils/process-rewards.util.d.ts

@@ -7,7 +7,12 @@ type Reward = {
         id: number;
         amount: number;
     }[];
-} & Omit<Partial<Record<RewardAcronym, number>>, "egg" | "seeds">;
+    "pet_food_pack.s"?: number;
+    "pet_food_pack.m"?: number;
+    "pet_food_pack.l"?: number;
+    "pet_food_pack.xl"?: number;
+    b?: number | number[];
+} & Omit<Partial<Record<RewardAcronym, number>>, "egg" | "seeds" | "b">;
 type ProcessedReward = {
     type: RewardType;
     element?: DragonElement;
@@ -17,6 +22,7 @@ type ProcessedReward = {
     dragon_ids?: number[];
     building_id?: number;
     orb_dragon_id?: number;
+    size?: string;
 };
 export declare function processRewards(rewards: Reward[]): ProcessedReward[];
 export {};

package/dist/utils/process-rewards.util.js

@@ -3,9 +3,15 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.processRewards = processRewards;
 const reward_type_enum_1 = require("../enums/reward-type.enum");
 const element_map_util_1 = require("./element-map.util");
+const is_blank_object_1 = require("./is-blank-object");
+const petFoodPackSizes = ["s", "m", "l", "xl"];
 function processRewards(rewards) {
+    const filteredRewards = rewards.filter(reward => !(0, is_blank_object_1.isBlankObject)(reward));
     const processedRewards = [];
-    for (const reward of rewards) {
+    for (const reward of filteredRewards) {
+        if ((0, is_blank_object_1.isBlankObject)(reward)) {
+            continue;
+        }
         if (reward.chest) {
             processedRewards.push({
                 type: reward_type_enum_1.RewardType.Chest,
@@ -45,10 +51,18 @@ function processRewards(rewards) {
             });
         }
         if (reward.b) {
-            processedRewards.push({
-                type: reward_type_enum_1.RewardType.Building,
-                building_id: reward.b,
-            });
+            if (Array.isArray(reward.b)) {
+                processedRewards.push({
+                    type: reward_type_enum_1.RewardType.Building,
+                    building_id: reward.b[0],
+                });
+            }
+            else {
+                processedRewards.push({
+                    type: reward_type_enum_1.RewardType.Building,
+                    building_id: reward.b,
+                });
+            }
         }
         if (reward.ep) {
             processedRewards.push({
@@ -83,8 +97,32 @@ function processRewards(rewards) {
                 amount: reward[key],
             });
         }
+        if (Object.keys(reward).some(key => petFoodPackSizes.some(size => key === `pet_food_pack.${size}`))) {
+            for (const size of petFoodPackSizes) {
+                const key = `pet_food_pack.${size}`;
+                if (key in reward) {
+                    processedRewards.push({
+                        type: reward_type_enum_1.RewardType.PetFoodPack,
+                        size,
+                        amount: reward[key],
+                    });
+                }
+            }
+        }
+        if (Object.keys(reward).some(key => key.startsWith("album_pack_aces."))) {
+            const key = Object.keys(reward).find(key => key.startsWith("album_pack_aces."));
+            const size = key === null || key === void 0 ? void 0 : key.split(".").pop();
+            if (!size) {
+                throw new Error("Invalid reward");
+            }
+            processedRewards.push({
+                type: reward_type_enum_1.RewardType.AlbumPackAces,
+                size: size,
+                amount: reward[key],
+            });
+        }
     }
-    if (processedRewards.length < rewards.length) {
+    if (processedRewards.length < filteredRewards.length) {
         throw new Error(`Not processed correctly: ${JSON.stringify(rewards)} -> ${JSON.stringify(processedRewards)}`);
     }
     return processedRewards;

package/package.json

@@ -1,44 +1,47 @@
-{
-  "name": "@dchighs/dc-config-mapper",
-  "version": "0.5.7",
-  "description": "A opined library to restructure and populate configuration for Dragon City.",
-  "main": "./dist/index.js",
-  "module": "./dist/index.js",
-  "types": "./dist/index.d.ts",
-  "files": [
-    "dist/*",
-    "!/**/__tests__"
-  ],
-  "keywords": [
-    "dragon city",
-    "dc",
-    "configuration",
-    "mapper",
-    "dc highs"
-  ],
-  "scripts": {
-    "build": "tsc",
-    "playground": "ts-node ./playground/index.ts"
-  },
-  "author": "Marcuth",
-  "license": "MIT",
-  "type": "commonjs",
-  "devDependencies": {
-    "@marcuth/env": "^0.0.1",
-    "@types/lodash": "^4.17.21",
-    "@types/node": "^25.0.3",
-    "@types/pluralize": "^0.0.33",
-    "ts-node": "^10.9.2",
-    "typescript": "^5.9.3"
-  },
-  "dependencies": {
-    "lodash": "^4.17.21",
-    "pluralize": "^8.0.0",
-    "zod": "^4.3.5"
-  },
-  "peerDependencies": {
-    "@dchighs/dc-config": "^0.0.1",
-    "@dchighs/dc-core": "^0.2.0",
-    "@dchighs/dc-localization": "^0.0.5"
-  }
-}
+{
+  "name": "@dchighs/dc-config-mapper",
+  "version": "0.5.9",
+  "description": "A opined library to restructure and populate configuration for Dragon City.",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist/*",
+    "!/**/__tests__"
+  ],
+  "keywords": [
+    "dragon city",
+    "dc",
+    "configuration",
+    "mapper",
+    "dc highs"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest run",
+    "playground": "ts-node ./playground/index.ts"
+  },
+  "author": "Marcuth",
+  "license": "MIT",
+  "type": "commonjs",
+  "devDependencies": {
+    "@marcuth/env": "^0.0.1",
+    "@types/lodash": "^4.17.24",
+    "@types/node": "^25.3.3",
+    "@types/pluralize": "^0.0.33",
+    "ts-morph": "^27.0.2",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.18"
+  },
+  "dependencies": {
+    "lodash": "^4.17.23",
+    "pluralize": "^8.0.0",
+    "zod": "^4.3.6"
+  },
+  "peerDependencies": {
+    "@dchighs/dc-config": "^0.0.6",
+    "@dchighs/dc-core": "^0.3.0",
+    "@dchighs/dc-localization": "^0.0.6"
+  }
+}

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

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

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

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