@dchighs/dc-config-mapper 0.1.4 → 0.2.1

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

@@ -0,0 +1,29 @@
+import { z } from "zod";
+export declare const towerIslandsFloorSchema: z.ZodPipe<z.ZodObject<{
+    id: z.ZodNumber;
+    y: z.ZodNumber;
+    x_flip: z.ZodNumber;
+    floor_image: z.ZodString;
+    area: z.ZodNumber;
+    roll_die_price: z.ZodObject<{
+        ep: z.ZodNumber;
+    }, z.core.$strip>;
+    island_id: z.ZodNumber;
+}, z.core.$strict>, z.ZodTransform<{
+    id: number;
+    y: number;
+    x_flip: boolean;
+    floor_image: string;
+    area: number;
+    roll_die_price: number;
+}, {
+    id: number;
+    y: number;
+    x_flip: number;
+    floor_image: string;
+    area: number;
+    roll_die_price: {
+        ep: number;
+    };
+    island_id: number;
+}>>;

package/dist/schemas/islands/tower-islands/floor.schema.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.towerIslandsFloorSchema = void 0;
+const zod_1 = require("zod");
+const utils_1 = require("../../../utils");
+exports.towerIslandsFloorSchema = zod_1.z.object({
+    id: zod_1.z.number(),
+    y: zod_1.z.number(),
+    x_flip: zod_1.z.number(),
+    floor_image: zod_1.z.string(),
+    area: zod_1.z.number(),
+    roll_die_price: zod_1.z.object({
+        ep: zod_1.z.number(),
+    }),
+    island_id: zod_1.z.number(),
+}).strict().transform(data => {
+    return {
+        id: data.id,
+        y: data.y,
+        x_flip: (0, utils_1.numberToBoolean)(data.x_flip),
+        floor_image: data.floor_image,
+        area: data.area,
+        roll_die_price: data.roll_die_price.ep,
+    };
+});

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

@@ -0,0 +1,98 @@
+import { z } from "zod";
+export declare const towerIslandSchema: z.ZodPipe<z.ZodObject<{
+    id: z.ZodNumber;
+    analytics_id: z.ZodString;
+    tid_name: z.ZodString;
+    start_ts: z.ZodNumber;
+    end_ts: z.ZodNumber;
+    initial_square_id: z.ZodNumber;
+    tutorial_id: z.ZodNumber;
+    tutorial_die_result: z.ZodNumber;
+    pool_size: z.ZodNumber;
+    pool_time: z.ZodNumber;
+    initial_points: z.ZodNumber;
+    currency_id: z.ZodNumber;
+    min_level: z.ZodNumber;
+    building_id: z.ZodNumber;
+    building_position: z.ZodArray<z.ZodNumber>;
+    tower_size: z.ZodArray<z.ZodNumber>;
+    zip_file: z.ZodString;
+    sound_tag: z.ZodString;
+    canvas_assets_url: z.ZodString;
+    mobile_first_floor_position: z.ZodArray<z.ZodNumber>;
+    mobile_floor_height: z.ZodNumber;
+    mobile_interior_wall_margin: z.ZodNumber;
+    mobile_final_dragon_scale: z.ZodArray<z.ZodNumber>;
+    mobile_final_dragon_position: z.ZodArray<z.ZodNumber>;
+    mobile_final_dragon_info_position: z.ZodArray<z.ZodNumber>;
+    max_die_roll: z.ZodNumber;
+    help_view_id: z.ZodNumber;
+    active_platforms: z.ZodObject<{
+        ios: z.ZodArray<z.ZodNumber>;
+        canvas: z.ZodArray<z.ZodNumber>;
+        android: z.ZodArray<z.ZodNumber>;
+        amazon: z.ZodArray<z.ZodNumber>;
+        windows: z.ZodArray<z.ZodNumber>;
+    }, z.core.$strip>;
+    square_ids: z.ZodArray<z.ZodNumber>;
+    floor_ids: z.ZodArray<z.ZodNumber>;
+}, z.core.$strict>, z.ZodTransform<{
+    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[];
+}, {
+    id: number;
+    analytics_id: string;
+    tid_name: string;
+    start_ts: number;
+    end_ts: number;
+    initial_square_id: number;
+    tutorial_id: number;
+    tutorial_die_result: number;
+    pool_size: number;
+    pool_time: number;
+    initial_points: number;
+    currency_id: number;
+    min_level: number;
+    building_id: number;
+    building_position: number[];
+    tower_size: number[];
+    zip_file: string;
+    sound_tag: string;
+    canvas_assets_url: string;
+    mobile_first_floor_position: number[];
+    mobile_floor_height: number;
+    mobile_interior_wall_margin: number;
+    mobile_final_dragon_scale: number[];
+    mobile_final_dragon_position: number[];
+    mobile_final_dragon_info_position: number[];
+    max_die_roll: number;
+    help_view_id: number;
+    active_platforms: {
+        ios: number[];
+        canvas: number[];
+        android: number[];
+        amazon: number[];
+        windows: number[];
+    };
+    square_ids: number[];
+    floor_ids: number[];
+}>>;

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

@@ -0,0 +1,71 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.towerIslandSchema = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+const zod_1 = require("zod");
+exports.towerIslandSchema = zod_1.z.object({
+    id: zod_1.z.number(),
+    analytics_id: zod_1.z.string(),
+    tid_name: zod_1.z.string(),
+    start_ts: zod_1.z.number(),
+    end_ts: zod_1.z.number(),
+    initial_square_id: zod_1.z.number(),
+    tutorial_id: zod_1.z.number(),
+    tutorial_die_result: zod_1.z.number(),
+    pool_size: zod_1.z.number(),
+    pool_time: zod_1.z.number(),
+    initial_points: zod_1.z.number(),
+    currency_id: zod_1.z.number(),
+    min_level: zod_1.z.number(),
+    building_id: zod_1.z.number(),
+    building_position: zod_1.z.array(zod_1.z.number()),
+    tower_size: zod_1.z.array(zod_1.z.number()),
+    zip_file: zod_1.z.string(),
+    sound_tag: zod_1.z.string(),
+    canvas_assets_url: zod_1.z.string(),
+    mobile_first_floor_position: zod_1.z.array(zod_1.z.number()),
+    mobile_floor_height: zod_1.z.number(),
+    mobile_interior_wall_margin: zod_1.z.number(),
+    mobile_final_dragon_scale: zod_1.z.array(zod_1.z.number()),
+    mobile_final_dragon_position: zod_1.z.array(zod_1.z.number()),
+    mobile_final_dragon_info_position: zod_1.z.array(zod_1.z.number()),
+    max_die_roll: zod_1.z.number(),
+    help_view_id: zod_1.z.number(),
+    active_platforms: zod_1.z.object({
+        ios: zod_1.z.array(zod_1.z.number()),
+        canvas: zod_1.z.array(zod_1.z.number()),
+        android: zod_1.z.array(zod_1.z.number()),
+        amazon: zod_1.z.array(zod_1.z.number()),
+        windows: zod_1.z.array(zod_1.z.number()),
+    }),
+    // injected properties
+    square_ids: zod_1.z.array(zod_1.z.number()),
+    floor_ids: zod_1.z.array(zod_1.z.number()),
+}).strict().transform(data => {
+    return {
+        id: data.id,
+        name_key: data.tid_name,
+        availability: {
+            from: new Date(data.start_ts * 1000).toISOString(),
+            to: new Date(data.end_ts * 1000).toISOString(),
+        },
+        initial_square_id: data.initial_square_id,
+        pool: {
+            size: data.pool_size,
+            time: data.pool_time,
+        },
+        initial_points: data.initial_points,
+        currency_id: data.currency_id,
+        min_level: data.min_level,
+        tower_size: data.tower_size,
+        zip_file_name: node_path_1.default.basename(data.zip_file),
+        sound_tag: data.sound_tag,
+        max_die_roll: data.max_die_roll,
+        help_view_id: data.help_view_id,
+        square_ids: data.square_ids,
+        floor_ids: data.floor_ids,
+    };
+});

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

@@ -0,0 +1,25 @@
+import { z } from "zod";
+export declare const towerIslandsRewardSchema: z.ZodPipe<z.ZodObject<{
+    id: z.ZodNumber;
+    dragon_reward_id: z.ZodNumber;
+    last_piece_cost: z.ZodNumber;
+    num_pieces: z.ZodNumber;
+    show_new_badge: z.ZodNumber;
+    area: z.ZodNumber;
+    island_id: z.ZodNumber;
+}, z.core.$strict>, z.ZodTransform<{
+    id: number;
+    dragon_id: number;
+    last_piece_cost: number;
+    pieces_count: number;
+    show_new_badge: boolean;
+    area: number;
+}, {
+    id: number;
+    dragon_reward_id: number;
+    last_piece_cost: number;
+    num_pieces: number;
+    show_new_badge: number;
+    area: number;
+    island_id: number;
+}>>;

package/dist/schemas/islands/tower-islands/reward.schema.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.towerIslandsRewardSchema = void 0;
+const zod_1 = require("zod");
+const utils_1 = require("../../../utils");
+exports.towerIslandsRewardSchema = zod_1.z.object({
+    id: zod_1.z.number(),
+    dragon_reward_id: zod_1.z.number(),
+    last_piece_cost: zod_1.z.number(),
+    num_pieces: zod_1.z.number(),
+    show_new_badge: zod_1.z.number(),
+    area: zod_1.z.number(),
+    island_id: zod_1.z.number(),
+}).strict().transform(data => {
+    return {
+        id: data.id,
+        dragon_id: data.dragon_reward_id,
+        last_piece_cost: data.last_piece_cost,
+        pieces_count: data.num_pieces,
+        show_new_badge: (0, utils_1.numberToBoolean)(data.show_new_badge),
+        area: data.area,
+    };
+});

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

@@ -0,0 +1,51 @@
+import { z } from "zod";
+export declare const towerIslandsSquareSchema: z.ZodPipe<z.ZodObject<{
+    id: z.ZodNumber;
+    type: z.ZodString;
+    highlight: z.ZodNumber;
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+    island_id: z.ZodNumber;
+    ixy: z.ZodString;
+    rewards_array: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        chest: z.ZodOptional<z.ZodNumber>;
+        egg: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>>;
+    wall: z.ZodOptional<z.ZodString>;
+    catapult_destination_square_id: z.ZodOptional<z.ZodNumber>;
+    piece_reward_id: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>, z.ZodTransform<{
+    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;
+}, {
+    id: number;
+    type: string;
+    highlight: number;
+    x: number;
+    y: number;
+    island_id: number;
+    ixy: string;
+    rewards_array?: {
+        chest?: number | undefined;
+        egg?: number | undefined;
+    }[] | undefined;
+    wall?: string | undefined;
+    catapult_destination_square_id?: number | undefined;
+    piece_reward_id?: number | undefined;
+}>>;

package/dist/schemas/islands/tower-islands/square.schema.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.towerIslandsSquareSchema = void 0;
+const zod_1 = require("zod");
+const utils_1 = require("../../../utils");
+exports.towerIslandsSquareSchema = zod_1.z.object({
+    id: zod_1.z.number(),
+    type: zod_1.z.string(),
+    highlight: zod_1.z.number(),
+    x: zod_1.z.number(),
+    y: zod_1.z.number(),
+    island_id: zod_1.z.number(),
+    ixy: zod_1.z.string(),
+    rewards_array: zod_1.z.array(zod_1.z.object({
+        chest: zod_1.z.number().optional(),
+        egg: zod_1.z.number().optional(),
+    })).optional(),
+    wall: zod_1.z.string().optional(),
+    catapult_destination_square_id: zod_1.z.number().optional(),
+    piece_reward_id: zod_1.z.number().optional(),
+}).strict().transform(data => {
+    return {
+        id: data.id,
+        type: data.type,
+        is_highlight: (0, utils_1.numberToBoolean)(data.highlight),
+        x: data.x,
+        y: data.y,
+        ixy: data.ixy,
+        rewards: data.rewards_array ? (0, utils_1.processRewards)(data.rewards_array) : null,
+        wall: data.wall,
+        catapult_destination_square_id: data.catapult_destination_square_id,
+        piece_reward_id: data.piece_reward_id,
+    };
+});

package/dist/schemas/items/building.schema.js

@@ -3,28 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildingSchema = void 0;
 const zod_1 = require("zod");
 const utils_1 = require("../../utils");
-const enums_1 = require("../../enums");
-const processPrice = (priceObj) => {
-    const keys = Object.keys(priceObj);
-    if (keys.length === 0)
-        return null;
-    if (keys.length > 1) {
-        throw new Error(`Unexpected multiple price keys: ${JSON.stringify(priceObj)}`);
-    }
-    const key = keys[0];
-    const amount = priceObj[key];
-    const typeMap = {
-        [enums_1.CostType.Gold]: "gold",
-        [enums_1.CostType.Gem]: "gem",
-    };
-    if (!typeMap[key]) {
-        throw new Error(`Unexpected price key: ${key}`);
-    }
-    return {
-        type: typeMap[key],
-        amount: amount,
-    };
-};
 exports.buildingSchema = zod_1.z.object({
     id: zod_1.z.number(),
     name: zod_1.z.string(),
@@ -99,7 +77,7 @@ exports.buildingSchema = zod_1.z.object({
         element_type: data.element_type,
         xp_on_build: data.xp,
         min_level: data.min_level,
-        buy_price: processPrice(data.costs),
+        buy_price: (0, utils_1.processPrice)(data.costs),
         display_order: data.display_order,
         boost_modifier: data.boost_modifier,
         cost_unit_cash: data.cost_unit_cash,
@@ -124,7 +102,7 @@ exports.buildingSchema = zod_1.z.object({
         description: data.description,
         properties: data.properties,
         building_ownership_id: data.building_ownership_id,
-        sell_price: data.sell_price ? processPrice(data.sell_price) : null,
+        sell_price: data.sell_price ? (0, utils_1.processPrice)(data.sell_price) : null,
         inventory_ids: data.inventory_ids,
     };
 });

package/dist/schemas/items/deco.schema.js

@@ -3,28 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.decoSchema = void 0;
 const zod_1 = require("zod");
 const utils_1 = require("../../utils");
-const enums_1 = require("../../enums");
-const processPrice = (priceObj) => {
-    const keys = Object.keys(priceObj);
-    if (keys.length === 0)
-        return null;
-    if (keys.length > 1) {
-        throw new Error(`Unexpected multiple price keys: ${JSON.stringify(priceObj)}`);
-    }
-    const key = keys[0];
-    const amount = priceObj[key];
-    const typeMap = {
-        [enums_1.CostType.Gold]: "gold",
-        [enums_1.CostType.Gem]: "gem",
-    };
-    if (!typeMap[key]) {
-        throw new Error(`Unexpected price key: ${key}`);
-    }
-    return {
-        type: typeMap[key],
-        amount: amount,
-    };
-};
 exports.decoSchema = zod_1.z.object({
     id: zod_1.z.number(),
     name: zod_1.z.string(),
@@ -98,8 +76,8 @@ exports.decoSchema = zod_1.z.object({
         element_type: data.element_type,
         xp_on_build: data.xp,
         min_level: data.min_level,
-        buy_price: processPrice(data.costs),
-        sell_price: data.sell_price ? processPrice(data.sell_price) : null,
+        buy_price: (0, utils_1.processPrice)(data.costs),
+        sell_price: data.sell_price ? (0, utils_1.processPrice)(data.sell_price) : null,
         display_order: data.display_order,
         boost_modifier: data.boost_modifier,
         cost_unit_cash: data.cost_unit_cash,

package/dist/schemas/items/dragon.schema.js

@@ -2,30 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.dragonSchema = void 0;
 const zod_1 = require("zod");
-const number_to_boolean_util_1 = require("../../utils/number-to-boolean.util");
+const utils_1 = require("../../utils");
 const element_map_util_1 = require("../../utils/element-map.util");
-const enums_1 = require("../../enums");
-const processPrice = (priceObj) => {
-    const keys = Object.keys(priceObj);
-    if (keys.length === 0)
-        return null;
-    if (keys.length > 1) {
-        throw new Error(`Unexpected multiple price keys: ${JSON.stringify(priceObj)}`);
-    }
-    const key = keys[0];
-    const amount = priceObj[key];
-    const typeMap = {
-        [enums_1.CostType.Gold]: "gold",
-        [enums_1.CostType.Gem]: "gem",
-    };
-    if (!typeMap[key]) {
-        throw new Error(`Unexpected price key: ${key}`);
-    }
-    return {
-        type: typeMap[key],
-        amount: amount,
-    };
-};
 exports.dragonSchema = zod_1.z.object({
     id: zod_1.z.number(),
     name: zod_1.z.string(),
@@ -108,11 +86,11 @@ exports.dragonSchema = zod_1.z.object({
         elements: data.attributes.map((element) => element_map_util_1.elementMap[element]),
         description: data.description,
         description_key: `tid_unit_${data.id}_description`,
-        buy_price: processPrice(data.costs),
-        sell_price: processPrice(data.sell_price),
-        is_breedable: (0, number_to_boolean_util_1.numberToBoolean)(data.breedable),
-        can_breed: (0, number_to_boolean_util_1.numberToBoolean)(data.can_breed),
-        is_in_store: (0, number_to_boolean_util_1.numberToBoolean)(data.in_store),
+        buy_price: (0, utils_1.processPrice)(data.costs),
+        sell_price: (0, utils_1.processPrice)(data.sell_price),
+        is_breedable: (0, utils_1.numberToBoolean)(data.breedable),
+        can_breed: (0, utils_1.numberToBoolean)(data.can_breed),
+        is_in_store: (0, utils_1.numberToBoolean)(data.in_store),
         min_store_level: data.in_store_min_level,
         basic_attack_ids: data.attacks,
         trainable_attack_ids: data.trainable_attacks,

package/dist/utils/index.d.ts

@@ -1,3 +1,5 @@
 export * from "./number-to-boolean.util";
 export * from "./record-keys-conversor.util";
 export * from "./element-map.util";
+export * from "./process-rewards.util";
+export * from "./process-price.util";

package/dist/utils/index.js

@@ -17,3 +17,5 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./number-to-boolean.util"), exports);
 __exportStar(require("./record-keys-conversor.util"), exports);
 __exportStar(require("./element-map.util"), exports);
+__exportStar(require("./process-rewards.util"), exports);
+__exportStar(require("./process-price.util"), exports);

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

@@ -0,0 +1,4 @@
+export declare function processPrice(price: Record<string, number>): {
+    type: string;
+    amount: number;
+} | null;

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

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processPrice = processPrice;
+const enums_1 = require("../enums");
+function processPrice(price) {
+    const keys = Object.keys(price);
+    if (keys.length === 0)
+        return null;
+    if (keys.length > 1) {
+        throw new Error(`Unexpected multiple price keys: ${JSON.stringify(price)}`);
+    }
+    const key = keys[0];
+    const amount = price[key];
+    const typeMap = {
+        [enums_1.CostType.Gold]: "gold",
+        [enums_1.CostType.Gem]: "gem",
+    };
+    if (!typeMap[key]) {
+        throw new Error(`Unexpected price key: ${key}`);
+    }
+    return {
+        type: typeMap[key],
+        amount: amount,
+    };
+}

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

@@ -0,0 +1,17 @@
+import { DragonElement } from "@dchighs/dc-core";
+import { RewardAcronym } from "../enums/reward-acronym.enum";
+import { RewardType } from "../enums/reward-type.enum";
+type Reward = {
+    egg?: number | number[];
+} & Omit<Partial<Record<RewardAcronym, number>>, "egg">;
+type ProcessedReward = {
+    type: RewardType;
+    element?: DragonElement;
+    amount?: number;
+    chest_id?: number;
+    dragon_id?: number;
+    dragon_ids?: number[];
+    building_id?: number;
+};
+export declare function processRewards(rewards: Reward[]): ProcessedReward[];
+export {};

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

@@ -0,0 +1,67 @@
+"use strict";
+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");
+function processRewards(rewards) {
+    const processedRewards = [];
+    for (const reward of rewards) {
+        if (reward.chest) {
+            processedRewards.push({
+                type: reward_type_enum_1.RewardType.Chest,
+                chest_id: reward.chest,
+            });
+        }
+        if (reward.egg) {
+            if (Array.isArray(reward.egg)) {
+                processedRewards.push({
+                    type: reward_type_enum_1.RewardType.Dragon,
+                    dragon_ids: reward.egg,
+                });
+            }
+            else {
+                processedRewards.push({
+                    type: reward_type_enum_1.RewardType.Dragon,
+                    dragon_id: reward.egg,
+                });
+            }
+        }
+        if (reward.g) {
+            processedRewards.push({
+                type: reward_type_enum_1.RewardType.Gold,
+                amount: reward.g,
+            });
+        }
+        if (reward.c) {
+            processedRewards.push({
+                type: reward_type_enum_1.RewardType.Gem,
+                amount: reward.c,
+            });
+        }
+        if (reward.f) {
+            processedRewards.push({
+                type: reward_type_enum_1.RewardType.Gem,
+                amount: reward.c,
+            });
+        }
+        if (reward.b) {
+            processedRewards.push({
+                type: reward_type_enum_1.RewardType.Building,
+                building_id: reward.b,
+            });
+        }
+        if (Object.keys(reward).some(key => key.endsWith("_token"))) {
+            const key = Object.keys(reward).find(key => key.endsWith("_token"));
+            const elementAcronym = key === null || key === void 0 ? void 0 : key.split("_")[0];
+            if (!elementAcronym) {
+                throw new Error("Invalid reward");
+            }
+            processedRewards.push({
+                type: reward_type_enum_1.RewardType.HabitatToken,
+                element: element_map_util_1.elementMap[elementAcronym],
+                amount: reward[key],
+            });
+        }
+    }
+    return processedRewards;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dchighs/dc-config-mapper",
-  "version": "0.1.4",
+  "version": "0.2.1",
   "description": "A opined library to restructure and populate configuration for Dragon City.",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -37,6 +37,7 @@
   },
   "peerDependencies": {
     "@dchighs/dc-config": "^0.0.1",
+    "@dchighs/dc-core": "^0.1.0",
     "@dchighs/dc-localization": "^0.0.4"
   }
 }