@dchighs/dc-config-mapper 0.3.2 → 0.5.0

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

@@ -0,0 +1,101 @@
+import { Localization } from "@dchighs/dc-localization";
+import { GameConfigDto } from "@dchighs/dc-config";
+type FogIslandDto = GameConfigDto["game_data"]["config"]["fog_island"];
+export declare class FogIslandsMapper {
+    readonly localization: Localization;
+    constructor(localization: Localization);
+    map(fogIslands: FogIslandDto): {
+        islands: import("@dchighs/dc-localization/dist/types").Translated<{
+            id: number;
+            availability: {
+                from: string;
+                to: string;
+            };
+            name_key: string;
+            board_size: {
+                width: number;
+                height: number;
+            };
+            cell_size: {
+                width: number;
+                height: number;
+            };
+            initial_square_id: number;
+            pool: {
+                points: number;
+                time: number;
+            };
+            initial_points: number;
+            currency_id: number;
+            min_level: number;
+            zip_file_name: string;
+            sound_tag: string;
+            square_ids: number[];
+        }>[];
+        squares: {
+            id: number;
+            type: string;
+            reward: {
+                chest_id: number | undefined;
+                type: string;
+            } | {
+                piece_dragon_id: number | undefined;
+                type: string;
+            } | null;
+            is_highlight: boolean;
+            x: number;
+            y: number;
+            cost: number;
+            come_back_cost: number;
+            reward_id: number | undefined;
+        }[];
+        currencies: {
+            id: number;
+            tid_name: string;
+            actions: Array<number>;
+        }[];
+        rewards: {
+            id: number;
+            type: string;
+            dragon_id: number;
+            last_piece_cost: number;
+            num_pieces: number;
+            show_new_badge: boolean;
+        }[];
+        actions: {
+            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;
+            };
+        }[];
+        hints: {
+            id: number;
+            type: string;
+            tid_name: string;
+            icon: string;
+            price: {
+                ep: number;
+            };
+            duration_time: number;
+            area: number;
+            square_selection: number;
+            increment_price: number;
+            tutorial_id: number;
+        }[];
+        parameters: {
+            id: number;
+            name: string;
+            value: any;
+        }[];
+    };
+}
+export {};

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

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FogIslandsMapper = void 0;
+const island_schema_1 = require("../schemas/islands/fog-islands/island.schema");
+const square_schema_1 = require("../schemas/islands/fog-islands/square.schema");
+const reward_schema_1 = require("../schemas/islands/fog-islands/reward.schema");
+class FogIslandsMapper {
+    constructor(localization) {
+        this.localization = localization;
+    }
+    map(fogIslands) {
+        return {
+            islands: fogIslands.islands.map(island => {
+                const squareIds = fogIslands.squares
+                    .filter(square => square.island_id === island.id)
+                    .map(square => square.id);
+                return this.localization.translate(island_schema_1.fogIslandSchema.parse({
+                    ...island,
+                    square_ids: squareIds,
+                }));
+            }),
+            squares: fogIslands.squares.map(square => square_schema_1.fogIslandsSquareSchema.parse(square)),
+            currencies: fogIslands.currencies,
+            rewards: fogIslands.rewards.map(reward => reward_schema_1.fogIslandsRewardSchema.parse(reward)),
+            actions: fogIslands.actions,
+            hints: fogIslands.hints,
+            parameters: fogIslands.parameters,
+        };
+    }
+}
+exports.FogIslandsMapper = FogIslandsMapper;

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

@@ -53,13 +53,13 @@ export declare class GridIslandsMapper {
             is_highlight: boolean;
             x: number;
             y: number;
-            claim_cost: number;
+            cost: number;
             wall: string | undefined;
             wall_suffix: string | undefined;
         }[];
         decorations: {
             id: number;
-            filename: string;
+            file_name: string;
             x: number;
             y: number;
         }[];

package/dist/mappers/index.d.ts

@@ -5,3 +5,5 @@ export * from "./heroic-races.mapper";
 export * from "./maze-islands.mapper";
 export * from "./tower-islands.mapper";
 export * from "./grid-islands.mapper";
+export * from "./fog-islands.mapper";
+export * from "./runner-islands.mapper";

package/dist/mappers/index.js

@@ -21,3 +21,5 @@ __exportStar(require("./heroic-races.mapper"), exports);
 __exportStar(require("./maze-islands.mapper"), exports);
 __exportStar(require("./tower-islands.mapper"), exports);
 __exportStar(require("./grid-islands.mapper"), exports);
+__exportStar(require("./fog-islands.mapper"), exports);
+__exportStar(require("./runner-islands.mapper"), exports);

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

@@ -0,0 +1,139 @@
+import { Localization } from "@dchighs/dc-localization";
+import { GameConfigDto } from "@dchighs/dc-config";
+type RunnerIslandDto = GameConfigDto["game_data"]["config"]["runner_island"];
+export declare class RunnerIslandsMapper {
+    readonly localization: Localization;
+    constructor(localization: Localization);
+    map(runnerIslands: RunnerIslandDto): {
+        islands: import("@dchighs/dc-localization/dist/types").Translated<{
+            id: number;
+            availability: {
+                from: string;
+                to: string;
+            };
+            name_key: string;
+            sound_tag: string;
+            zip_file_name: string;
+            run_cost: number;
+            mission_pool_ids: number[];
+            milestone_reward_ids: number[];
+        }>[];
+        sections: {
+            id: number;
+            starting_point: number;
+            speed: number;
+            level_chunks: Array<{
+                id: number;
+                weight: number;
+            }>;
+            rewards: Array<number>;
+            background_layers: Array<{
+                texture: string;
+                speed: number;
+                positionY: number;
+            }>;
+        }[];
+        parameters: {
+            id: number;
+            name: string;
+            value: any;
+        }[];
+        obstacles: {
+            id: number;
+            texture: string;
+            length: number;
+            is_tall: boolean;
+        }[];
+        level_chunks: {
+            id: number;
+            lane_1: any;
+            lane_2: Array<{
+                reward?: string;
+                position: number;
+                jump?: boolean;
+                obstacle_id?: number;
+            }>;
+            lane_3: Array<{
+                reward?: string;
+                position: number;
+                jump?: boolean;
+                obstacle_id?: number;
+            }>;
+            length: number;
+        }[];
+        level_rewards: {
+            id: number;
+            resource_id: number;
+            type: string;
+            custom_texture?: string;
+        }[];
+        missions: import("@dchighs/dc-localization/dist/types").Translated<{
+            id: number;
+            type: string;
+            name_key: string;
+            goal_points: number;
+            price: number;
+            price_increment: number;
+            pool_size: number;
+            spawn_time: number;
+            collect_chance: number;
+            collect_chance_modifier: number;
+            points: number;
+        }>[];
+        rewards: {
+            id: number;
+            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;
+            }[];
+            type_id: number;
+            double_with_video_ad: boolean | undefined;
+            premium_rewards: number[] | undefined;
+            new_badge: number[] | undefined;
+        }[];
+        rewards_config: {
+            id: number;
+            background: string;
+            title_tid: string;
+            title_show_tid: string;
+            description_tid: string;
+            description_show_tid: string;
+            button_tid: string;
+            button_claim_double_tid: string;
+            animated_dragon: boolean;
+            adult_dragon: boolean;
+        }[];
+        rewards_tiers: {
+            name: string;
+            value: any;
+        }[];
+        milestones: {
+            id: number;
+            positionX: number;
+            positionY: number;
+            points: number;
+            texture: string;
+            animated_asset: string;
+        }[];
+        milestone_rewards: {
+            id: number;
+            points: number;
+            reward_id: number;
+            is_highlight: boolean;
+            is_focused: boolean;
+        }[];
+        mission_pools: {
+            id: number;
+            buy_all_discounts: number;
+            mission_ids: number[];
+            price: number;
+            price_increment: number;
+        }[];
+    };
+}
+export {};

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

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RunnerIslandsMapper = void 0;
+const island_schema_1 = require("../schemas/islands/runner-islands/island.schema");
+const mission_schema_1 = require("../schemas/islands/runner-islands/mission.schema");
+const reward_schema_1 = require("../schemas/islands/runner-islands/reward.schema");
+const milestone_reward_schema_1 = require("../schemas/islands/runner-islands/milestone-reward.schema");
+const mission_pool_schema_1 = require("../schemas/islands/runner-islands/mission-pool.schema");
+class RunnerIslandsMapper {
+    constructor(localization) {
+        this.localization = localization;
+    }
+    map(runnerIslands) {
+        return {
+            islands: runnerIslands.islands.map(island => this.localization.translate(island_schema_1.runnerIslandSchema.parse(island))),
+            sections: runnerIslands.sections,
+            parameters: runnerIslands.parameters,
+            obstacles: runnerIslands.obstacles,
+            level_chunks: runnerIslands.level_chunks,
+            level_rewards: runnerIslands.level_rewards,
+            missions: runnerIslands.missions.map(mission => this.localization.translate(mission_schema_1.runnerIslandsMissionSchema.parse(mission))),
+            rewards: runnerIslands.rewards.map(reward => reward_schema_1.runnerIslandsRewardSchema.parse(reward)),
+            rewards_config: runnerIslands.rewards_config,
+            rewards_tiers: runnerIslands.rewards_tiers,
+            milestones: runnerIslands.milestones,
+            milestone_rewards: runnerIslands.milestone_rewards.map(reward => milestone_reward_schema_1.runnerIslandsMilestoneRewardSchema.parse(reward)),
+            mission_pools: runnerIslands.mission_pool.map(missionPool => mission_pool_schema_1.runnerIslandsMissionPoolSchema.parse(missionPool)),
+        };
+    }
+}
+exports.RunnerIslandsMapper = RunnerIslandsMapper;

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

@@ -0,0 +1,82 @@
+import { z } from "zod";
+export declare const fogIslandSchema: z.ZodPipe<z.ZodObject<{
+    id: z.ZodNumber;
+    analytics_id: z.ZodString;
+    tid_name: z.ZodString;
+    tutorial_id: z.ZodNumber;
+    tutorial_claimable_cell_id: z.ZodNumber;
+    board_size: z.ZodArray<z.ZodNumber>;
+    cell_size: z.ZodArray<z.ZodNumber>;
+    origin_offset: z.ZodArray<z.ZodNumber>;
+    initial_square_id: z.ZodNumber;
+    pool_points: z.ZodNumber;
+    pool_time: z.ZodNumber;
+    initial_points: z.ZodNumber;
+    start_ts: z.ZodNumber;
+    end_ts: z.ZodNumber;
+    currency_id: z.ZodNumber;
+    min_level: z.ZodNumber;
+    building_id: z.ZodNumber;
+    building_position: z.ZodArray<z.ZodNumber>;
+    zip_file: z.ZodString;
+    sound_tag: z.ZodString;
+    canvas_assets_url: z.ZodString;
+    background_plist: z.ZodString;
+    foregrounds_plists: z.ZodArray<z.ZodAny>;
+    particles_position: z.ZodArray<z.ZodNumber>;
+    tutorial_claim_cells: z.ZodArray<z.ZodNumber>;
+    square_ids: z.ZodArray<z.ZodNumber>;
+}, z.core.$strict>, z.ZodTransform<{
+    id: number;
+    availability: {
+        from: string;
+        to: string;
+    };
+    name_key: string;
+    board_size: {
+        width: number;
+        height: number;
+    };
+    cell_size: {
+        width: number;
+        height: number;
+    };
+    initial_square_id: number;
+    pool: {
+        points: number;
+        time: number;
+    };
+    initial_points: number;
+    currency_id: number;
+    min_level: number;
+    zip_file_name: string;
+    sound_tag: string;
+    square_ids: number[];
+}, {
+    id: number;
+    analytics_id: string;
+    tid_name: string;
+    tutorial_id: number;
+    tutorial_claimable_cell_id: number;
+    board_size: number[];
+    cell_size: number[];
+    origin_offset: number[];
+    initial_square_id: number;
+    pool_points: number;
+    pool_time: number;
+    initial_points: number;
+    start_ts: number;
+    end_ts: number;
+    currency_id: number;
+    min_level: number;
+    building_id: number;
+    building_position: number[];
+    zip_file: string;
+    sound_tag: string;
+    canvas_assets_url: string;
+    background_plist: string;
+    foregrounds_plists: any[];
+    particles_position: number[];
+    tutorial_claim_cells: number[];
+    square_ids: number[];
+}>>;

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

@@ -0,0 +1,94 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fogIslandSchema = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+const zod_1 = require("zod");
+/*
+{
+                    id: number;
+                    analytics_id: string;
+                    tid_name: string;
+                    tutorial_id: number;
+                    tutorial_claimable_cell_id: number;
+                    board_size: Array<number>;
+                    cell_size: Array<number>;
+                    origin_offset: Array<number>;
+                    initial_square_id: number;
+                    pool_points: number;
+                    pool_time: number;
+                    initial_points: number;
+                    start_ts: number;
+                    end_ts: number;
+                    currency_id: number;
+                    min_level: number;
+                    building_id: number;
+                    building_position: Array<number>;
+                    zip_file: string;
+                    sound_tag: string;
+                    canvas_assets_url: string;
+                    background_plist: string;
+                    foregrounds_plists: Array<any>;
+                    particles_position: Array<number>;
+                    tutorial_claim_cells: Array<number>;
+                }
+*/
+exports.fogIslandSchema = zod_1.z.object({
+    id: zod_1.z.number(),
+    analytics_id: zod_1.z.string(),
+    tid_name: zod_1.z.string(),
+    tutorial_id: zod_1.z.number(),
+    tutorial_claimable_cell_id: zod_1.z.number(),
+    board_size: zod_1.z.array(zod_1.z.number()),
+    cell_size: zod_1.z.array(zod_1.z.number()),
+    origin_offset: zod_1.z.array(zod_1.z.number()),
+    initial_square_id: zod_1.z.number(),
+    pool_points: zod_1.z.number(),
+    pool_time: zod_1.z.number(),
+    initial_points: zod_1.z.number(),
+    start_ts: zod_1.z.number(),
+    end_ts: 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()),
+    zip_file: zod_1.z.string(),
+    sound_tag: zod_1.z.string(),
+    canvas_assets_url: zod_1.z.string(),
+    background_plist: zod_1.z.string(),
+    foregrounds_plists: zod_1.z.array(zod_1.z.any()),
+    particles_position: zod_1.z.array(zod_1.z.number()),
+    tutorial_claim_cells: zod_1.z.array(zod_1.z.number()),
+    // injected props
+    square_ids: zod_1.z.array(zod_1.z.number()),
+}).strict().transform(data => {
+    return {
+        id: data.id,
+        availability: {
+            from: new Date(data.start_ts * 1000).toISOString(),
+            to: new Date(data.end_ts * 1000).toISOString(),
+        },
+        name_key: data.tid_name,
+        board_size: {
+            width: data.board_size[0],
+            height: data.board_size[1],
+        },
+        cell_size: {
+            width: data.cell_size[0],
+            height: data.cell_size[1],
+        },
+        initial_square_id: data.initial_square_id,
+        pool: {
+            points: data.pool_points,
+            time: data.pool_time,
+        },
+        initial_points: data.initial_points,
+        currency_id: data.currency_id,
+        min_level: data.min_level,
+        zip_file_name: node_path_1.default.basename(data.zip_file),
+        sound_tag: data.sound_tag,
+        square_ids: data.square_ids,
+    };
+});

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

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

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

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fogIslandsRewardSchema = void 0;
+const zod_1 = require("zod");
+const utils_1 = require("../../../utils");
+exports.fogIslandsRewardSchema = zod_1.z.object({
+    id: zod_1.z.number(),
+    type: zod_1.z.string(),
+    island_id: zod_1.z.number(),
+    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(),
+}).strict().transform(data => {
+    return {
+        id: data.id,
+        type: data.type,
+        dragon_id: data.reward_id,
+        last_piece_cost: data.last_piece_cost,
+        num_pieces: data.num_pieces,
+        show_new_badge: (0, utils_1.numberToBoolean)(data.show_new_badge),
+    };
+});

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

@@ -0,0 +1,40 @@
+import { z } from "zod";
+export declare const fogIslandsSquareSchema: z.ZodPipe<z.ZodObject<{
+    id: z.ZodNumber;
+    type: z.ZodString;
+    type_id: z.ZodOptional<z.ZodNumber>;
+    highlight: z.ZodNumber;
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+    island_id: z.ZodNumber;
+    claim_cost: z.ZodNumber;
+    come_back_cost: z.ZodNumber;
+    reward_id: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>, z.ZodTransform<{
+    id: number;
+    type: string;
+    reward: {
+        chest_id: number | undefined;
+        type: string;
+    } | {
+        piece_dragon_id: number | undefined;
+        type: string;
+    } | null;
+    is_highlight: boolean;
+    x: number;
+    y: number;
+    cost: number;
+    come_back_cost: number;
+    reward_id: number | undefined;
+}, {
+    id: number;
+    type: string;
+    highlight: number;
+    x: number;
+    y: number;
+    island_id: number;
+    claim_cost: number;
+    come_back_cost: number;
+    type_id?: number | undefined;
+    reward_id?: number | undefined;
+}>>;

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

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fogIslandsSquareSchema = void 0;
+const zod_1 = require("zod");
+const utils_1 = require("../../../utils");
+exports.fogIslandsSquareSchema = zod_1.z.object({
+    id: zod_1.z.number(),
+    type: zod_1.z.string(),
+    type_id: zod_1.z.number().optional(),
+    highlight: zod_1.z.number(),
+    x: zod_1.z.number(),
+    y: zod_1.z.number(),
+    island_id: zod_1.z.number(),
+    claim_cost: zod_1.z.number(),
+    come_back_cost: zod_1.z.number(),
+    reward_id: zod_1.z.number().optional(),
+}).strict().transform(data => {
+    return {
+        id: data.id,
+        type: data.type,
+        reward: data.type === "NONE" || data.type === "STEP" ? null : {
+            type: data.type,
+            ...(data.type === "CHEST" ? {
+                chest_id: data.type_id,
+            } : {
+                piece_dragon_id: data.type_id,
+            })
+        },
+        is_highlight: (0, utils_1.numberToBoolean)(data.highlight),
+        x: data.x,
+        y: data.y,
+        cost: data.claim_cost,
+        come_back_cost: data.come_back_cost,
+        reward_id: data.reward_id,
+    };
+});

package/dist/schemas/islands/grid-islands/decoration.schema.d.ts

@@ -8,7 +8,7 @@ export declare const gridIslandsDecorationSchema: z.ZodPipe<z.ZodObject<{
     episode_id: z.ZodNumber;
 }, z.core.$strict>, z.ZodTransform<{
     id: number;
-    filename: string;
+    file_name: string;
     x: number;
     y: number;
 }, {

package/dist/schemas/islands/grid-islands/decoration.schema.js

@@ -12,7 +12,7 @@ exports.gridIslandsDecorationSchema = zod_1.z.object({
 }).strict().transform(data => {
     return {
         id: data.id,
-        filename: data.file,
+        file_name: `${data.file}.png`,
         x: data.x,
         y: data.y,
     };

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

@@ -24,7 +24,7 @@ export declare const gridIslandsSquareSchema: z.ZodPipe<z.ZodObject<{
     is_highlight: boolean;
     x: number;
     y: number;
-    claim_cost: number;
+    cost: number;
     wall: string | undefined;
     wall_suffix: string | undefined;
 }, {

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

@@ -30,7 +30,7 @@ exports.gridIslandsSquareSchema = zod_1.z.object({
         is_highlight: (0, utils_1.numberToBoolean)(data.highlight),
         x: data.x,
         y: data.y,
-        claim_cost: data.claim_cost,
+        cost: data.claim_cost,
         wall: data.wall,
         wall_suffix: data.wall_suffix,
     };

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

@@ -0,0 +1,52 @@
+import { z } from "zod";
+export declare const runnerIslandSchema: z.ZodPipe<z.ZodObject<{
+    id: z.ZodNumber;
+    start_ts: z.ZodNumber;
+    end_ts: z.ZodNumber;
+    building_id: z.ZodNumber;
+    building_position: z.ZodArray<z.ZodNumber>;
+    dragon_id: z.ZodNumber;
+    dragon_offset: z.ZodArray<z.ZodNumber>;
+    dragon_scale: z.ZodNumber;
+    runner_dragon_asset: z.ZodOptional<z.ZodString>;
+    zip_file: z.ZodString;
+    help_id: z.ZodNumber;
+    run_cost: z.ZodNumber;
+    sound_tag: z.ZodString;
+    mission_pool: z.ZodArray<z.ZodNumber>;
+    sections: z.ZodArray<z.ZodNumber>;
+    building_tooltip_position: z.ZodArray<z.ZodNumber>;
+    building_timer_position: z.ZodArray<z.ZodNumber>;
+    milestone_rewards: z.ZodArray<z.ZodNumber>;
+}, z.core.$strict>, z.ZodTransform<{
+    id: number;
+    availability: {
+        from: string;
+        to: string;
+    };
+    name_key: string;
+    sound_tag: string;
+    zip_file_name: string;
+    run_cost: number;
+    mission_pool_ids: number[];
+    milestone_reward_ids: number[];
+}, {
+    id: number;
+    start_ts: number;
+    end_ts: number;
+    building_id: number;
+    building_position: number[];
+    dragon_id: number;
+    dragon_offset: number[];
+    dragon_scale: number;
+    zip_file: string;
+    help_id: number;
+    run_cost: number;
+    sound_tag: string;
+    mission_pool: number[];
+    sections: number[];
+    building_tooltip_position: number[];
+    building_timer_position: number[];
+    milestone_rewards: number[];
+    runner_dragon_asset?: string | undefined;
+}>>;

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

@@ -0,0 +1,64 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runnerIslandSchema = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+const zod_1 = require("zod");
+/*
+{
+                    id: number;
+                    start_ts: number;
+                    end_ts: number;
+                    building_id: number;
+                    building_position: Array<number>;
+                    dragon_id: number;
+                    dragon_offset: Array<number>;
+                    dragon_scale: number;
+                    runner_dragon_asset?: string;
+                    zip_file: string;
+                    help_id: number;
+                    run_cost: number;
+                    sound_tag: string;
+                    mission_pool: Array<number>;
+                    sections: Array<number>;
+                    building_tooltip_position: Array<number>;
+                    building_timer_position: Array<number>;
+                    milestone_rewards: Array<number>;
+                }
+*/
+exports.runnerIslandSchema = zod_1.z.object({
+    id: zod_1.z.number(),
+    start_ts: zod_1.z.number(),
+    end_ts: zod_1.z.number(),
+    building_id: zod_1.z.number(),
+    building_position: zod_1.z.array(zod_1.z.number()),
+    dragon_id: zod_1.z.number(),
+    dragon_offset: zod_1.z.array(zod_1.z.number()),
+    dragon_scale: zod_1.z.number(),
+    runner_dragon_asset: zod_1.z.string().optional(),
+    zip_file: zod_1.z.string(),
+    help_id: zod_1.z.number(),
+    run_cost: zod_1.z.number(),
+    sound_tag: zod_1.z.string(),
+    mission_pool: zod_1.z.array(zod_1.z.number()),
+    sections: zod_1.z.array(zod_1.z.number()),
+    building_tooltip_position: zod_1.z.array(zod_1.z.number()),
+    building_timer_position: zod_1.z.array(zod_1.z.number()),
+    milestone_rewards: zod_1.z.array(zod_1.z.number()),
+}).strict().transform(data => {
+    return {
+        id: data.id,
+        availability: {
+            from: new Date(data.start_ts * 1000).toISOString(),
+            to: new Date(data.end_ts * 1000).toISOString(),
+        },
+        name_key: `tid_runner_island_${data.id}_title`,
+        sound_tag: data.sound_tag,
+        zip_file_name: node_path_1.default.basename(data.zip_file),
+        run_cost: data.run_cost,
+        mission_pool_ids: data.mission_pool,
+        milestone_reward_ids: data.milestone_rewards,
+    };
+});

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

@@ -0,0 +1,20 @@
+import { z } from "zod";
+export declare const runnerIslandsMilestoneRewardSchema: z.ZodPipe<z.ZodObject<{
+    id: z.ZodNumber;
+    points: z.ZodNumber;
+    reward_id: z.ZodNumber;
+    highlighted: z.ZodNumber;
+    focused: z.ZodNumber;
+}, z.core.$strict>, z.ZodTransform<{
+    id: number;
+    points: number;
+    reward_id: number;
+    is_highlight: boolean;
+    is_focused: boolean;
+}, {
+    id: number;
+    points: number;
+    reward_id: number;
+    highlighted: number;
+    focused: number;
+}>>;

package/dist/schemas/islands/runner-islands/milestone-reward.schema.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runnerIslandsMilestoneRewardSchema = void 0;
+const zod_1 = require("zod");
+const utils_1 = require("../../../utils");
+exports.runnerIslandsMilestoneRewardSchema = zod_1.z.object({
+    id: zod_1.z.number(),
+    points: zod_1.z.number(),
+    reward_id: zod_1.z.number(),
+    highlighted: zod_1.z.number(),
+    focused: zod_1.z.number()
+}).strict().transform(data => {
+    return {
+        id: data.id,
+        points: data.points,
+        reward_id: data.reward_id,
+        is_highlight: (0, utils_1.numberToBoolean)(data.highlighted),
+        is_focused: (0, utils_1.numberToBoolean)(data.focused),
+    };
+});

package/dist/schemas/islands/runner-islands/mission-pool.schema.d.ts

@@ -0,0 +1,20 @@
+import { z } from "zod";
+export declare const runnerIslandsMissionPoolSchema: z.ZodPipe<z.ZodObject<{
+    id: z.ZodNumber;
+    buy_all_discounts: z.ZodNumber;
+    missions: z.ZodArray<z.ZodNumber>;
+    price: z.ZodNumber;
+    price_increment: z.ZodNumber;
+}, z.core.$strict>, z.ZodTransform<{
+    id: number;
+    buy_all_discounts: number;
+    mission_ids: number[];
+    price: number;
+    price_increment: number;
+}, {
+    id: number;
+    buy_all_discounts: number;
+    missions: number[];
+    price: number;
+    price_increment: number;
+}>>;

package/dist/schemas/islands/runner-islands/mission-pool.schema.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runnerIslandsMissionPoolSchema = void 0;
+const zod_1 = require("zod");
+exports.runnerIslandsMissionPoolSchema = zod_1.z.object({
+    id: zod_1.z.number(),
+    buy_all_discounts: zod_1.z.number(),
+    missions: zod_1.z.array(zod_1.z.number()),
+    price: zod_1.z.number(),
+    price_increment: zod_1.z.number()
+}).strict().transform(data => {
+    return {
+        id: data.id,
+        buy_all_discounts: data.buy_all_discounts,
+        mission_ids: data.missions,
+        price: data.price,
+        price_increment: data.price_increment
+    };
+});

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

@@ -0,0 +1,36 @@
+import { z } from "zod";
+export declare const runnerIslandsMissionSchema: z.ZodPipe<z.ZodObject<{
+    id: z.ZodNumber;
+    type: z.ZodString;
+    goal_points: z.ZodNumber;
+    price: z.ZodNumber;
+    price_increment: z.ZodNumber;
+    pool_size: z.ZodNumber;
+    spawn_time: z.ZodNumber;
+    collect_chance: z.ZodNumber;
+    collect_chance_modifier: z.ZodNumber;
+    energy: z.ZodNumber;
+}, z.core.$strict>, z.ZodTransform<{
+    id: number;
+    type: string;
+    name_key: string;
+    goal_points: number;
+    price: number;
+    price_increment: number;
+    pool_size: number;
+    spawn_time: number;
+    collect_chance: number;
+    collect_chance_modifier: number;
+    points: number;
+}, {
+    id: number;
+    type: string;
+    goal_points: number;
+    price: number;
+    price_increment: number;
+    pool_size: number;
+    spawn_time: number;
+    collect_chance: number;
+    collect_chance_modifier: number;
+    energy: number;
+}>>;

package/dist/schemas/islands/runner-islands/mission.schema.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runnerIslandsMissionSchema = void 0;
+const zod_1 = require("zod");
+const runner_islands_mission_name_map_util_1 = require("../../../utils/runner-islands-mission-name-map.util");
+exports.runnerIslandsMissionSchema = zod_1.z.object({
+    id: zod_1.z.number(),
+    type: zod_1.z.string(),
+    goal_points: zod_1.z.number(),
+    price: zod_1.z.number(),
+    price_increment: zod_1.z.number(),
+    pool_size: zod_1.z.number(),
+    spawn_time: zod_1.z.number(),
+    collect_chance: zod_1.z.number(),
+    collect_chance_modifier: zod_1.z.number(),
+    energy: zod_1.z.number(),
+}).strict().transform(data => {
+    return {
+        id: data.id,
+        type: data.type,
+        name_key: runner_islands_mission_name_map_util_1.runnerIslandsMissionNameMap[data.type],
+        goal_points: data.goal_points,
+        price: data.price,
+        price_increment: data.price_increment,
+        pool_size: data.pool_size,
+        spawn_time: data.spawn_time,
+        collect_chance: data.collect_chance,
+        collect_chance_modifier: data.collect_chance_modifier,
+        points: data.energy,
+    };
+});

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

@@ -0,0 +1,83 @@
+import { z } from "zod";
+export declare const runnerIslandsRewardSchema: z.ZodPipe<z.ZodObject<{
+    id: z.ZodNumber;
+    reward: z.ZodArray<z.ZodObject<{
+        chest: z.ZodOptional<z.ZodNumber>;
+        ep: z.ZodOptional<z.ZodNumber>;
+        egg: z.ZodOptional<z.ZodNumber>;
+        c: z.ZodOptional<z.ZodNumber>;
+        seeds: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodNumber;
+            amount: z.ZodNumber;
+        }, z.core.$strip>>>;
+        f: z.ZodOptional<z.ZodNumber>;
+        g: z.ZodOptional<z.ZodNumber>;
+        en_runner: z.ZodOptional<z.ZodNumber>;
+        f_token: z.ZodOptional<z.ZodNumber>;
+        pu_token: z.ZodOptional<z.ZodNumber>;
+        i_token: z.ZodOptional<z.ZodNumber>;
+        wr_token: z.ZodOptional<z.ZodNumber>;
+        el_token: z.ZodOptional<z.ZodNumber>;
+        wd_token: z.ZodOptional<z.ZodNumber>;
+        m_token: z.ZodOptional<z.ZodNumber>;
+        w_token: z.ZodOptional<z.ZodNumber>;
+        pr_token: z.ZodOptional<z.ZodNumber>;
+        e_token: z.ZodOptional<z.ZodNumber>;
+        d_token: z.ZodOptional<z.ZodNumber>;
+        p_token: z.ZodOptional<z.ZodNumber>;
+        li_token: z.ZodOptional<z.ZodNumber>;
+        l_token: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    type_id: z.ZodNumber;
+    double_with_video_ad: z.ZodOptional<z.ZodBoolean>;
+    premium_rewards: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+    new_badge: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+}, z.core.$strict>, z.ZodTransform<{
+    id: number;
+    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;
+    }[];
+    type_id: number;
+    double_with_video_ad: boolean | undefined;
+    premium_rewards: number[] | undefined;
+    new_badge: number[] | undefined;
+}, {
+    id: number;
+    reward: {
+        chest?: number | undefined;
+        ep?: number | undefined;
+        egg?: number | undefined;
+        c?: number | undefined;
+        seeds?: {
+            id: number;
+            amount: number;
+        }[] | undefined;
+        f?: number | undefined;
+        g?: number | undefined;
+        en_runner?: number | undefined;
+        f_token?: number | undefined;
+        pu_token?: number | undefined;
+        i_token?: number | undefined;
+        wr_token?: number | undefined;
+        el_token?: number | undefined;
+        wd_token?: number | undefined;
+        m_token?: number | undefined;
+        w_token?: number | undefined;
+        pr_token?: number | undefined;
+        e_token?: number | undefined;
+        d_token?: number | undefined;
+        p_token?: number | undefined;
+        li_token?: number | undefined;
+        l_token?: number | undefined;
+    }[];
+    type_id: number;
+    double_with_video_ad?: boolean | undefined;
+    premium_rewards?: number[] | undefined;
+    new_badge?: number[] | undefined;
+}>>;

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

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runnerIslandsRewardSchema = void 0;
+const zod_1 = require("zod");
+const utils_1 = require("../../../utils");
+exports.runnerIslandsRewardSchema = zod_1.z.object({
+    id: zod_1.z.number(),
+    reward: zod_1.z.array(zod_1.z.object({
+        chest: zod_1.z.number().optional(),
+        ep: zod_1.z.number().optional(),
+        egg: zod_1.z.number().optional(),
+        c: zod_1.z.number().optional(),
+        seeds: zod_1.z.array(zod_1.z.object({
+            id: zod_1.z.number(),
+            amount: zod_1.z.number(),
+        })).optional(),
+        f: zod_1.z.number().optional(),
+        g: zod_1.z.number().optional(),
+        en_runner: zod_1.z.number().optional(),
+        f_token: zod_1.z.number().optional(),
+        pu_token: zod_1.z.number().optional(),
+        i_token: zod_1.z.number().optional(),
+        wr_token: zod_1.z.number().optional(),
+        el_token: zod_1.z.number().optional(),
+        wd_token: zod_1.z.number().optional(),
+        m_token: zod_1.z.number().optional(),
+        w_token: zod_1.z.number().optional(),
+        pr_token: zod_1.z.number().optional(),
+        e_token: zod_1.z.number().optional(),
+        d_token: zod_1.z.number().optional(),
+        p_token: zod_1.z.number().optional(),
+        li_token: zod_1.z.number().optional(),
+        l_token: zod_1.z.number().optional(),
+    })),
+    type_id: zod_1.z.number(),
+    double_with_video_ad: zod_1.z.boolean().optional(),
+    premium_rewards: zod_1.z.array(zod_1.z.number()).optional(),
+    new_badge: zod_1.z.array(zod_1.z.number()).optional(),
+}).strict().transform(data => {
+    return {
+        id: data.id,
+        rewards: (0, utils_1.processRewards)(data.reward),
+        type_id: data.type_id,
+        double_with_video_ad: data.double_with_video_ad,
+        premium_rewards: data.premium_rewards,
+        new_badge: data.new_badge,
+    };
+});

package/dist/utils/runner-islands-mission-name-map.util.d.ts

@@ -0,0 +1 @@
+export declare const runnerIslandsMissionNameMap: Record<string, string>;

package/dist/utils/runner-islands-mission-name-map.util.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runnerIslandsMissionNameMap = void 0;
+exports.runnerIslandsMissionNameMap = {
+    feed: "tid_runner_mission_feed",
+    gold: "tid_runner_mission_collect_gold",
+    food: "tid_runner_mission_collect_food",
+    breed: "tid_runner_mission_breed",
+    hatch: "tid_runner_mission_hatch",
+    pvp: "tid_runner_mission_pvp",
+    battle: "tid_runner_mission_battle"
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dchighs/dc-config-mapper",
-  "version": "0.3.2",
+  "version": "0.5.0",
   "description": "A opined library to restructure and populate configuration for Dragon City.",
   "main": "./dist/index.js",
   "module": "./dist/index.js",