@dchighs/dc-config-mapper 0.0.2 → 0.1.2

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

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { RewardResourceType } from "../../enums/reward-resource-type";
+import { RewardResourceType } from "../../enums/reward-resource-type.enum";
 export declare const chestRewardSchema: z.ZodPipe<z.ZodObject<{
     id: z.ZodNumber;
     reward: z.ZodObject<{
@@ -55,7 +55,7 @@ export declare const chestRewardSchema: z.ZodPipe<z.ZodObject<{
             element: import("@dchighs/dc-core").DragonElement;
             amount: never;
         } | undefined;
-        buildings_ids: number[] | undefined;
+        building_ids: number[] | undefined;
         eggs_ids: number[] | undefined;
         seeds: {
             id: number;

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

@@ -2,27 +2,27 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.chestRewardSchema = void 0;
 const zod_1 = require("zod");
-const reward_resource_type_1 = require("../../enums/reward-resource-type");
-const element_map_1 = require("../../utils/element-map");
+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_1.RewardResourceType.Gem,
+            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_1.RewardResourceType.Food,
+            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_1.RewardResourceType.Gold,
+            type: reward_resource_type_enum_1.RewardResourceType.Gold,
             amount: rewardResource.g,
         };
     }
@@ -30,20 +30,20 @@ function processReward(rewardResource) {
     if (tokenKey) {
         const elementAcronym = tokenKey.replace("_token", "");
         return {
-            type: reward_resource_type_1.RewardResourceType.HabitatToken,
-            element: element_map_1.elementMap[elementAcronym],
+            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_1.RewardResourceType.IslandCoin,
+            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_1.RewardResourceType.Xp,
+            type: reward_resource_type_enum_1.RewardResourceType.Xp,
             amount: rewardResource.x,
         };
     }
@@ -95,7 +95,7 @@ exports.chestRewardSchema = zod_1.z.object({
 }).strict().transform((data) => {
     const reward = {
         resource: data.reward.resource ? processReward(data.reward.resource) : undefined,
-        buildings_ids: data.reward.buildings,
+        building_ids: data.reward.buildings,
         eggs_ids: data.reward.eggs,
         seeds: data.reward.seeds,
         moves: data.reward.moves,

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

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { RewardResourceType } from "../../../enums/reward-resource-type";
+import { RewardResourceType } from "../../../enums/reward-resource-type.enum";
 export declare const heroicRacesRewardSchema: z.ZodPipe<z.ZodObject<{
     id: z.ZodNumber;
     positions: z.ZodArray<z.ZodNumber>;

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

@@ -2,17 +2,17 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.heroicRacesRewardSchema = void 0;
 const zod_1 = require("zod");
-const reward_resource_type_1 = require("../../../enums/reward-resource-type");
+const reward_resource_type_enum_1 = require("../../../enums/reward-resource-type.enum");
 function processReward(reward) {
     if (reward.c) {
         return {
-            type: reward_resource_type_1.RewardResourceType.Gem,
+            type: reward_resource_type_enum_1.RewardResourceType.Gem,
             amount: reward.c,
         };
     }
     if (reward.egg) {
         return {
-            type: reward_resource_type_1.RewardResourceType.Dragon,
+            type: reward_resource_type_enum_1.RewardResourceType.Dragon,
             dragon_ids: reward.egg,
         };
     }

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

@@ -49,7 +49,6 @@ export declare const mazeIslandSchema: z.ZodPipe<z.ZodObject<{
     };
     initial_points: number;
     min_level: number;
-    building_id: number;
     mobile_tutorial_id: number;
     zip_file_name: string;
     sound_tag: string;

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

@@ -57,7 +57,6 @@ exports.mazeIslandSchema = zod_1.z.object({
         },
         initial_points: data.initial_points,
         min_level: data.min_level,
-        building_id: data.building_id,
         mobile_tutorial_id: data.mobile_tutorial_id,
         zip_file_name: node_path_1.default.basename(data.zip_file),
         sound_tag: data.sound_tag,

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

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { RewardResourceType } from "../../../enums/reward-resource-type";
+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,8 +22,7 @@ export declare const mazeIslandsNodeSchema: z.ZodPipe<z.ZodObject<{
 }, z.core.$strict>, z.ZodTransform<{
     id: number;
     cost: number;
-    reward_id: number | undefined;
-    reward: ({
+    rewards: ({
         type: RewardResourceType;
         amount: number;
         chest_id?: undefined;

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

@@ -2,29 +2,29 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.mazeIslandsNodeSchema = void 0;
 const zod_1 = require("zod");
-const reward_resource_type_1 = require("../../../enums/reward-resource-type");
+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_1.RewardResourceType.Food,
+            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_1.RewardResourceType.Gold,
+            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_1.RewardResourceType.Chest,
+            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_1.RewardResourceType.Building,
+            type: reward_resource_type_enum_1.RewardResourceType.Building,
             building_id: reward.b,
         };
     }
@@ -54,8 +54,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,
-        reward_id: data.reward_id,
-        reward: data.reward ? data.reward.map(processReward) : undefined,
+        rewards: data.reward ? data.reward.map(processReward) : undefined,
         is_highlighted: data.highlighted,
         key_path_id: data.key,
         encounter_id: data.encounter,

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

@@ -25,8 +25,8 @@ exports.mazeIslandsPathSchema = zod_1.z.object({
         has_new_badge: (0, utils_1.numberToBoolean)(data.new_badge),
         node_ids: data.nodes,
         availability: data.availability ? {
-            from: new Date(data.availability.from).toISOString(),
-            to: new Date(data.availability.to).toISOString(),
+            from: new Date(data.availability.from * 1000).toISOString(),
+            to: new Date(data.availability.to * 1000).toISOString(),
         } : undefined,
     };
 });

package/dist/schemas/items/building.schema.d.ts

@@ -0,0 +1,188 @@
+import { z } from "zod";
+export declare const buildingSchema: z.ZodPipe<z.ZodObject<{
+    id: z.ZodNumber;
+    name: z.ZodString;
+    group_type: z.ZodString;
+    name_key: z.ZodOptional<z.ZodString>;
+    animated: z.ZodNumber;
+    build_time: z.ZodNumber;
+    mobile_version: z.ZodNumber;
+    android_version: z.ZodNumber;
+    show_on_mobile: z.ZodNumber;
+    type: z.ZodString;
+    element_type: z.ZodOptional<z.ZodString>;
+    xp: z.ZodNumber;
+    min_level: z.ZodNumber;
+    costs: z.ZodObject<{
+        c: z.ZodOptional<z.ZodNumber>;
+        g: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+    display_order: z.ZodNumber;
+    boost_modifier: z.ZodNumber;
+    gift_level: z.ZodNumber;
+    giftable: z.ZodNumber;
+    cost_unit_cash: z.ZodOptional<z.ZodNumber>;
+    collect: z.ZodNumber;
+    collect_xp: z.ZodOptional<z.ZodNumber>;
+    category_id: z.ZodNumber;
+    subcategory_id: z.ZodNumber;
+    building_limit_same_id: z.ZodNumber;
+    in_store: z.ZodNumber;
+    width: z.ZodNumber;
+    height: z.ZodNumber;
+    new_item: z.ZodNumber;
+    img_name: z.ZodString;
+    img_name_mobile: z.ZodString;
+    img_name_android: z.ZodString;
+    activation: z.ZodNumber;
+    upgrades_to: z.ZodNumber;
+    collect_type: z.ZodAny;
+    velocity: z.ZodNumber;
+    description: z.ZodOptional<z.ZodString>;
+    properties: z.ZodObject<{
+        capacity: z.ZodOptional<z.ZodNumber>;
+        incubator: z.ZodOptional<z.ZodNumber>;
+        bulldozable: z.ZodOptional<z.ZodNumber>;
+        max_dragon_level: z.ZodOptional<z.ZodNumber>;
+        required_items: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+        workingBuilding: z.ZodOptional<z.ZodNumber>;
+        breeding: z.ZodOptional<z.ZodNumber>;
+        breeding_factor: z.ZodOptional<z.ZodNumber>;
+        max_gold: z.ZodOptional<z.ZodNumber>;
+        friend_assistable: z.ZodOptional<z.ZodNumber>;
+        upgrade_from: z.ZodOptional<z.ZodNumber>;
+        floating: z.ZodOptional<z.ZodNumber>;
+        fixed_position: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+        is_fixed: z.ZodOptional<z.ZodNumber>;
+        crosspromotion: z.ZodOptional<z.ZodNumber>;
+        ft_flying: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+    building_ownership_id: z.ZodNumber;
+    sell_price: z.ZodOptional<z.ZodObject<{
+        g: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    inventory_ids: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>, z.ZodTransform<{
+    id: number;
+    name: string;
+    name_key: string | undefined;
+    animated: boolean;
+    build_time: number;
+    type: string;
+    element_type: string | undefined;
+    xp_on_build: number;
+    min_level: number;
+    buy_price: {
+        type: string;
+        amount: number;
+    } | null;
+    display_order: number;
+    boost_modifier: number;
+    cost_unit_cash: number | undefined;
+    collect: number;
+    collect_xp: number | undefined;
+    category_id: number;
+    subcategory_id: number;
+    building_limit_same_id: number;
+    in_store: boolean;
+    width: number;
+    height: number;
+    new_item: boolean;
+    imageNames: {
+        default: string;
+        mobile: string;
+        android: string;
+    };
+    activation: number;
+    upgrades_to: number;
+    collect_type: any;
+    velocity: number;
+    description: string | undefined;
+    properties: {
+        capacity?: number | undefined;
+        incubator?: number | undefined;
+        bulldozable?: number | undefined;
+        max_dragon_level?: number | undefined;
+        required_items?: number[] | undefined;
+        workingBuilding?: number | undefined;
+        breeding?: number | undefined;
+        breeding_factor?: number | undefined;
+        max_gold?: number | undefined;
+        friend_assistable?: number | undefined;
+        upgrade_from?: number | undefined;
+        floating?: number | undefined;
+        fixed_position?: number[] | undefined;
+        is_fixed?: number | undefined;
+        crosspromotion?: number | undefined;
+        ft_flying?: number | undefined;
+    };
+    building_ownership_id: number;
+    sell_price: {
+        type: string;
+        amount: number;
+    } | null;
+    inventory_ids: number | undefined;
+}, {
+    id: number;
+    name: string;
+    group_type: string;
+    animated: number;
+    build_time: number;
+    mobile_version: number;
+    android_version: number;
+    show_on_mobile: number;
+    type: string;
+    xp: number;
+    min_level: number;
+    costs: {
+        c?: number | undefined;
+        g?: number | undefined;
+    };
+    display_order: number;
+    boost_modifier: number;
+    gift_level: number;
+    giftable: number;
+    collect: number;
+    category_id: number;
+    subcategory_id: number;
+    building_limit_same_id: number;
+    in_store: number;
+    width: number;
+    height: number;
+    new_item: number;
+    img_name: string;
+    img_name_mobile: string;
+    img_name_android: string;
+    activation: number;
+    upgrades_to: number;
+    collect_type: any;
+    velocity: number;
+    properties: {
+        capacity?: number | undefined;
+        incubator?: number | undefined;
+        bulldozable?: number | undefined;
+        max_dragon_level?: number | undefined;
+        required_items?: number[] | undefined;
+        workingBuilding?: number | undefined;
+        breeding?: number | undefined;
+        breeding_factor?: number | undefined;
+        max_gold?: number | undefined;
+        friend_assistable?: number | undefined;
+        upgrade_from?: number | undefined;
+        floating?: number | undefined;
+        fixed_position?: number[] | undefined;
+        is_fixed?: number | undefined;
+        crosspromotion?: number | undefined;
+        ft_flying?: number | undefined;
+    };
+    building_ownership_id: number;
+    name_key?: string | undefined;
+    element_type?: string | undefined;
+    cost_unit_cash?: number | undefined;
+    collect_xp?: number | undefined;
+    description?: string | undefined;
+    sell_price?: {
+        g?: number | undefined;
+    } | undefined;
+    inventory_ids?: number | undefined;
+}>>;

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

@@ -0,0 +1,130 @@
+"use strict";
+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(),
+    group_type: zod_1.z.string(),
+    name_key: zod_1.z.string().optional(),
+    animated: zod_1.z.number(),
+    build_time: zod_1.z.number(),
+    mobile_version: zod_1.z.number(),
+    android_version: zod_1.z.number(),
+    show_on_mobile: zod_1.z.number(),
+    type: zod_1.z.string(),
+    element_type: zod_1.z.string().optional(),
+    xp: zod_1.z.number(),
+    min_level: zod_1.z.number(),
+    costs: zod_1.z.object({
+        c: zod_1.z.number().optional(),
+        g: zod_1.z.number().optional(),
+    }),
+    display_order: zod_1.z.number(),
+    boost_modifier: zod_1.z.number(),
+    gift_level: zod_1.z.number(),
+    giftable: zod_1.z.number(),
+    cost_unit_cash: zod_1.z.number().optional(),
+    collect: zod_1.z.number(),
+    collect_xp: zod_1.z.number().optional(),
+    category_id: zod_1.z.number(),
+    subcategory_id: zod_1.z.number(),
+    building_limit_same_id: zod_1.z.number(),
+    in_store: zod_1.z.number(),
+    width: zod_1.z.number(),
+    height: zod_1.z.number(),
+    new_item: zod_1.z.number(),
+    img_name: zod_1.z.string(),
+    img_name_mobile: zod_1.z.string(),
+    img_name_android: zod_1.z.string(),
+    activation: zod_1.z.number(),
+    upgrades_to: zod_1.z.number(),
+    collect_type: zod_1.z.any(),
+    velocity: zod_1.z.number(),
+    description: zod_1.z.string().optional(),
+    properties: zod_1.z.object({
+        capacity: zod_1.z.number().optional(),
+        incubator: zod_1.z.number().optional(),
+        bulldozable: zod_1.z.number().optional(),
+        max_dragon_level: zod_1.z.number().optional(),
+        required_items: zod_1.z.array(zod_1.z.number()).optional(),
+        workingBuilding: zod_1.z.number().optional(),
+        breeding: zod_1.z.number().optional(),
+        breeding_factor: zod_1.z.number().optional(),
+        max_gold: zod_1.z.number().optional(),
+        friend_assistable: zod_1.z.number().optional(),
+        upgrade_from: zod_1.z.number().optional(),
+        floating: zod_1.z.number().optional(),
+        fixed_position: zod_1.z.array(zod_1.z.number()).optional(),
+        is_fixed: zod_1.z.number().optional(),
+        crosspromotion: zod_1.z.number().optional(),
+        ft_flying: zod_1.z.number().optional(),
+    }),
+    building_ownership_id: zod_1.z.number(),
+    sell_price: zod_1.z.object({
+        g: zod_1.z.number().optional(),
+    }).optional(),
+    inventory_ids: zod_1.z.number().optional(),
+}).strict().transform((data) => {
+    return {
+        id: data.id,
+        name: data.name,
+        name_key: data.name_key,
+        animated: (0, utils_1.numberToBoolean)(data.animated),
+        build_time: data.build_time,
+        type: data.type,
+        element_type: data.element_type,
+        xp_on_build: data.xp,
+        min_level: data.min_level,
+        buy_price: processPrice(data.costs),
+        display_order: data.display_order,
+        boost_modifier: data.boost_modifier,
+        cost_unit_cash: data.cost_unit_cash,
+        collect: data.collect,
+        collect_xp: data.collect_xp,
+        category_id: data.category_id,
+        subcategory_id: data.subcategory_id,
+        building_limit_same_id: data.building_limit_same_id,
+        in_store: (0, utils_1.numberToBoolean)(data.in_store),
+        width: data.width,
+        height: data.height,
+        new_item: (0, utils_1.numberToBoolean)(data.new_item),
+        imageNames: {
+            default: data.img_name,
+            mobile: data.img_name_mobile,
+            android: data.img_name_android,
+        },
+        activation: data.activation,
+        upgrades_to: data.upgrades_to,
+        collect_type: data.collect_type,
+        velocity: data.velocity,
+        description: data.description,
+        properties: data.properties,
+        building_ownership_id: data.building_ownership_id,
+        sell_price: data.sell_price ? processPrice(data.sell_price) : null,
+        inventory_ids: data.inventory_ids,
+    };
+});