@dchighs/dbgames 0.1.0

package/dist/parsing-models/dragon-page.model.d.ts

@@ -0,0 +1,70 @@
+import { HtmlExtractionModel } from "@xcrap/extractor";
+export declare const dragonPageExtractionModel: HtmlExtractionModel<{
+    heading: {
+        query: import("@xcrap/extractor").BuildedQuery;
+        extractor: import("@xcrap/extractor").ExtractorFunction<string | Promise<string | undefined> | undefined>;
+    };
+    description: {
+        query: import("@xcrap/extractor").BuildedQuery;
+        extractor: import("@xcrap/extractor").ExtractorFunction<string | Promise<string | undefined> | undefined>;
+    };
+    rarity: {
+        query: import("@xcrap/extractor").BuildedQuery;
+        extractor: import("@xcrap/extractor").ExtractorFunction<string | Promise<string | undefined> | undefined>;
+    };
+    elements: {
+        query: import("@xcrap/extractor").BuildedQuery;
+        multiple: true;
+        extractor: import("@xcrap/extractor").ExtractorFunction<string | Promise<string | undefined> | undefined>;
+    };
+    hatchingTime: {
+        query: import("@xcrap/extractor").BuildedQuery;
+        extractor: import("@xcrap/extractor").ExtractorFunction<string | Promise<string | undefined> | undefined>;
+    };
+    breedingTime: {
+        query: import("@xcrap/extractor").BuildedQuery;
+        extractor: import("@xcrap/extractor").ExtractorFunction<string | Promise<string | undefined> | undefined>;
+    };
+    goldProductionInfo: {
+        query: import("@xcrap/extractor").BuildedQuery;
+        default: null;
+        extractor: import("@xcrap/extractor").ExtractorFunction<string | Promise<string | undefined> | undefined>;
+    };
+    hatchingExperience: {
+        query: import("@xcrap/extractor").BuildedQuery;
+        extractor: import("@xcrap/extractor").ExtractorFunction<string | Promise<string | undefined> | undefined>;
+        default: null;
+    };
+    firstImageUrl: {
+        query: import("@xcrap/extractor").BuildedQuery;
+        extractor: import("@xcrap/extractor").ExtractorFunction<string | Promise<string | undefined> | undefined>;
+        default: null;
+    };
+    xpOnHatching: {
+        query: import("@xcrap/extractor").BuildedQuery;
+        extractor: import("@xcrap/extractor").ExtractorFunction<string | Promise<string | undefined> | undefined>;
+        default: null;
+    };
+    allAttacks: {
+        query: import("@xcrap/extractor").BuildedQuery;
+        multiple: true;
+        model: HtmlExtractionModel<{
+            name: {
+                query: import("@xcrap/extractor").BuildedQuery;
+                extractor: import("@xcrap/extractor").ExtractorFunction<string | Promise<string | undefined> | undefined>;
+            };
+            element: {
+                query: import("@xcrap/extractor").BuildedQuery;
+                extractor: import("@xcrap/extractor").ExtractorFunction<string | Promise<string | undefined> | undefined>;
+            };
+            trainingTime: {
+                query: import("@xcrap/extractor").BuildedQuery;
+                extractor: import("@xcrap/extractor").ExtractorFunction<string | Promise<string | undefined> | undefined>;
+            };
+            power: {
+                query: import("@xcrap/extractor").BuildedQuery;
+                extractor: import("@xcrap/extractor").ExtractorFunction<string | Promise<string | undefined> | undefined>;
+            };
+        }>;
+    };
+}>;

package/dist/parsing-models/dragon-page.model.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dragonPageExtractionModel = void 0;
+const extractor_1 = require("@xcrap/extractor");
+exports.dragonPageExtractionModel = new extractor_1.HtmlExtractionModel({
+    heading: {
+        query: (0, extractor_1.css)(".result-data:has(.entitytabledata) .subtitle:first-child"),
+        extractor: (0, extractor_1.extract)("textContent"),
+    },
+    description: {
+        query: (0, extractor_1.css)(".result-data:has(.entitytabledata) .col-sm-12.rhs.text-data"),
+        extractor: (0, extractor_1.extract)("innerText"),
+    },
+    rarity: {
+        query: (0, extractor_1.css)(".result-data:has(.entitytabledata) .rarity .iconized-text"),
+        extractor: (0, extractor_1.extract)("innerText"),
+    },
+    elements: {
+        query: (0, extractor_1.css)(".result-data:has(.entitytabledata) .element"),
+        multiple: true,
+        extractor: (0, extractor_1.extract)("innerText"),
+    },
+    hatchingTime: {
+        query: (0, extractor_1.css)(".result-data:has(.entitytabledata) tr:nth-child(4) .iconized-text"),
+        extractor: (0, extractor_1.extract)("innerText"),
+    },
+    breedingTime: {
+        query: (0, extractor_1.css)(".result-data:has(.entitytabledata) tr:nth-child(3) .iconized-text"),
+        extractor: (0, extractor_1.extract)("innerText"),
+    },
+    goldProductionInfo: {
+        query: (0, extractor_1.css)(".result-data:has(.entitytabledata) tr:nth-child(5) .iconized-text"),
+        default: null,
+        extractor: (0, extractor_1.extract)("innerText"),
+    },
+    hatchingExperience: {
+        query: (0, extractor_1.css)(".result-data:has(.entitytabledata) tr:nth-child(6) .iconized-text"),
+        extractor: (0, extractor_1.extract)("innerText"),
+        default: null,
+    },
+    firstImageUrl: {
+        query: (0, extractor_1.css)(".result-data:has(.entitytabledata) .col-xs-4:nth-child(1) .entityimg"),
+        extractor: (0, extractor_1.extract)("src"),
+        default: null,
+    },
+    xpOnHatching: {
+        query: (0, extractor_1.css)(".result-data:has(.entitytabledata) tr:nth-child(6) .iconized-text"),
+        extractor: (0, extractor_1.extract)("innerText"),
+        default: null,
+    },
+    allAttacks: {
+        query: (0, extractor_1.css)(".result-data:has(.text-right) > .row > .col-sm-12 > table > tbody > tr:not(:has(.subtitle))"),
+        multiple: true,
+        model: new extractor_1.HtmlExtractionModel({
+            name: {
+                query: (0, extractor_1.css)("td:nth-child(1)"),
+                extractor: (0, extractor_1.extract)("innerText"),
+            },
+            element: {
+                query: (0, extractor_1.css)("td:nth-child(2) a"),
+                extractor: (0, extractor_1.extract)("innerText"),
+            },
+            trainingTime: {
+                query: (0, extractor_1.css)("td:nth-child(3) .text-center"),
+                extractor: (0, extractor_1.extract)("innerText"),
+            },
+            power: {
+                query: (0, extractor_1.css)("td:nth-child(3) .text-right"),
+                extractor: (0, extractor_1.extract)("innerText"),
+            },
+        }),
+    },
+});

package/dist/parsing-models/dragon.model.d.ts

@@ -0,0 +1,48 @@
+import { HtmlExtractionModel } from "@xcrap/extractor";
+export declare const dragonExtractionModel: HtmlExtractionModel<{
+    heading: {
+        query: import("@xcrap/extractor").BuildedQuery;
+        extractor: import("@xcrap/extractor").ExtractorFunction<string | Promise<string | undefined> | undefined>;
+    };
+    description: {
+        query: import("@xcrap/extractor").BuildedQuery;
+        extractor: import("@xcrap/extractor").ExtractorFunction<string | Promise<string | undefined> | undefined>;
+    };
+    rarity: {
+        query: import("@xcrap/extractor").BuildedQuery;
+        extractor: import("@xcrap/extractor").ExtractorFunction<string | Promise<string | undefined> | undefined>;
+    };
+    elements: {
+        query: import("@xcrap/extractor").BuildedQuery;
+        multiple: true;
+        extractor: import("@xcrap/extractor").ExtractorFunction<string | Promise<string | undefined> | undefined>;
+    };
+    hatchingTime: {
+        query: import("@xcrap/extractor").BuildedQuery;
+        extractor: import("@xcrap/extractor").ExtractorFunction<string | Promise<string | undefined> | undefined>;
+    };
+    breedingTime: {
+        query: import("@xcrap/extractor").BuildedQuery;
+        extractor: import("@xcrap/extractor").ExtractorFunction<string | Promise<string | undefined> | undefined>;
+    };
+    goldProductionInfo: {
+        query: import("@xcrap/extractor").BuildedQuery;
+        default: null;
+        extractor: import("@xcrap/extractor").ExtractorFunction<string | Promise<string | undefined> | undefined>;
+    };
+    hatchingExperience: {
+        query: import("@xcrap/extractor").BuildedQuery;
+        extractor: import("@xcrap/extractor").ExtractorFunction<string | Promise<string | undefined> | undefined>;
+        default: null;
+    };
+    firstImageUrl: {
+        query: import("@xcrap/extractor").BuildedQuery;
+        extractor: import("@xcrap/extractor").ExtractorFunction<string | Promise<string | undefined> | undefined>;
+        default: null;
+    };
+    xpOnHatching: {
+        query: import("@xcrap/extractor").BuildedQuery;
+        extractor: import("@xcrap/extractor").ExtractorFunction<string | Promise<string | undefined> | undefined>;
+        default: null;
+    };
+}>;

package/dist/parsing-models/dragon.model.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dragonExtractionModel = void 0;
+const extractor_1 = require("@xcrap/extractor");
+exports.dragonExtractionModel = new extractor_1.HtmlExtractionModel({
+    heading: {
+        query: (0, extractor_1.css)(".subtitle:first-child"),
+        extractor: (0, extractor_1.extract)("textContent"),
+    },
+    description: {
+        query: (0, extractor_1.css)(".col-sm-12.rhs.text-data"),
+        extractor: (0, extractor_1.extract)("innerText"),
+    },
+    rarity: {
+        query: (0, extractor_1.css)(".rarity .iconized-text"),
+        extractor: (0, extractor_1.extract)("innerText"),
+    },
+    elements: {
+        query: (0, extractor_1.css)(".element"),
+        multiple: true,
+        extractor: (0, extractor_1.extract)("innerText"),
+    },
+    hatchingTime: {
+        query: (0, extractor_1.css)("tr:nth-child(4) .iconized-text"),
+        extractor: (0, extractor_1.extract)("innerText"),
+    },
+    breedingTime: {
+        query: (0, extractor_1.css)("tr:nth-child(3) .iconized-text"),
+        extractor: (0, extractor_1.extract)("innerText"),
+    },
+    goldProductionInfo: {
+        query: (0, extractor_1.css)("tr:nth-child(5) .iconized-text"),
+        default: null,
+        extractor: (0, extractor_1.extract)("innerText"),
+    },
+    hatchingExperience: {
+        query: (0, extractor_1.css)("tr:nth-child(6) .iconized-text"),
+        extractor: (0, extractor_1.extract)("innerText"),
+        default: null,
+    },
+    firstImageUrl: {
+        query: (0, extractor_1.css)(".col-xs-4:nth-child(1) .entityimg"),
+        extractor: (0, extractor_1.extract)("src"),
+        default: null,
+    },
+    xpOnHatching: {
+        query: (0, extractor_1.css)("tr:nth-child(6) .iconized-text"),
+        extractor: (0, extractor_1.extract)("innerText"),
+        default: null,
+    },
+});

package/dist/parsing-models/dragons-page.model.d.ts

@@ -0,0 +1,54 @@
+import { HtmlExtractionModel } from "@xcrap/extractor";
+export declare const dragonsPageExtractionModel: HtmlExtractionModel<{
+    dragons: {
+        query: import("@xcrap/extractor").BuildedQuery;
+        multiple: true;
+        model: HtmlExtractionModel<{
+            heading: {
+                query: import("@xcrap/extractor").BuildedQuery;
+                extractor: import("@xcrap/extractor").ExtractorFunction<string | Promise<string | undefined> | undefined>;
+            };
+            description: {
+                query: import("@xcrap/extractor").BuildedQuery;
+                extractor: import("@xcrap/extractor").ExtractorFunction<string | Promise<string | undefined> | undefined>;
+            };
+            rarity: {
+                query: import("@xcrap/extractor").BuildedQuery;
+                extractor: import("@xcrap/extractor").ExtractorFunction<string | Promise<string | undefined> | undefined>;
+            };
+            elements: {
+                query: import("@xcrap/extractor").BuildedQuery;
+                multiple: true;
+                extractor: import("@xcrap/extractor").ExtractorFunction<string | Promise<string | undefined> | undefined>;
+            };
+            hatchingTime: {
+                query: import("@xcrap/extractor").BuildedQuery;
+                extractor: import("@xcrap/extractor").ExtractorFunction<string | Promise<string | undefined> | undefined>;
+            };
+            breedingTime: {
+                query: import("@xcrap/extractor").BuildedQuery;
+                extractor: import("@xcrap/extractor").ExtractorFunction<string | Promise<string | undefined> | undefined>;
+            };
+            goldProductionInfo: {
+                query: import("@xcrap/extractor").BuildedQuery;
+                default: null;
+                extractor: import("@xcrap/extractor").ExtractorFunction<string | Promise<string | undefined> | undefined>;
+            };
+            hatchingExperience: {
+                query: import("@xcrap/extractor").BuildedQuery;
+                extractor: import("@xcrap/extractor").ExtractorFunction<string | Promise<string | undefined> | undefined>;
+                default: null;
+            };
+            firstImageUrl: {
+                query: import("@xcrap/extractor").BuildedQuery;
+                extractor: import("@xcrap/extractor").ExtractorFunction<string | Promise<string | undefined> | undefined>;
+                default: null;
+            };
+            xpOnHatching: {
+                query: import("@xcrap/extractor").BuildedQuery;
+                extractor: import("@xcrap/extractor").ExtractorFunction<string | Promise<string | undefined> | undefined>;
+                default: null;
+            };
+        }>;
+    };
+}>;

package/dist/parsing-models/dragons-page.model.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dragonsPageExtractionModel = void 0;
+const extractor_1 = require("@xcrap/extractor");
+const dragon_model_1 = require("./dragon.model");
+exports.dragonsPageExtractionModel = new extractor_1.HtmlExtractionModel({
+    dragons: {
+        query: (0, extractor_1.css)(".result-data:has(.col-sm-12.rhs.text-data)"),
+        multiple: true,
+        model: dragon_model_1.dragonExtractionModel,
+    },
+});

package/dist/transforming-models/dragon-page.model.d.ts

@@ -0,0 +1,2 @@
+import { TransformingModel } from "@xcrap/transformer";
+export declare const dragonPageTransformingModel: TransformingModel;

package/dist/transforming-models/dragon-page.model.js

@@ -0,0 +1,257 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dragonPageTransformingModel = void 0;
+const transformer_1 = require("@xcrap/transformer");
+const dc_core_1 = require("@dchighs/dc-core");
+const utils_1 = require("../utils");
+const regex_helper_1 = require("../helpers/regex.helper");
+const attackTransformingModel = new transformer_1.TransformingModel({
+    name: [
+        (0, transformer_1.transform)({
+            key: "name",
+            transformer: transformer_1.StringTransformer.trim,
+        }),
+        (0, transformer_1.transform)({
+            key: "name",
+            condition: (value) => value === "Judo Kick",
+            transformer: () => "Judo Throw",
+        }),
+        (0, transformer_1.transform)({
+            key: "name",
+            condition: (value) => value === "Karate Brick Break",
+            transformer: () => "Brick Break",
+        }),
+        (0, transformer_1.transform)({
+            key: "name",
+            condition: (value) => value === "Head Butt",
+            transformer: () => "Headbutt",
+        }),
+        (0, transformer_1.transform)({
+            key: "name",
+            condition: (value) => value === "Original Pain",
+            transformer: () => "Archaic Pain",
+        }),
+    ],
+    type: [
+        (0, transformer_1.transform)({
+            key: "element",
+            transformer: transformer_1.StringTransformer.trim,
+        }),
+        (0, transformer_1.transform)({
+            key: "type",
+            transformer: transformer_1.StringTransformer.toLowerCase,
+        }),
+    ],
+    element: [
+        (0, transformer_1.transform)({
+            key: "element",
+            transformer: transformer_1.StringTransformer.trim,
+        }),
+        (0, transformer_1.transform)({
+            key: "element",
+            transformer: transformer_1.StringTransformer.toLowerCase,
+        }),
+        (0, transformer_1.transform)({
+            key: "element",
+            transformer: (element) => dc_core_1.elementSettings[element].acronym,
+        }),
+    ],
+    ui_damage: [
+        (0, transformer_1.transform)({
+            key: "power",
+            transformer: transformer_1.StringTransformer.toNumber,
+        }),
+    ],
+    training_time: [
+        (0, transformer_1.transform)({
+            key: "trainingTime",
+            transformer: utils_1.stringDurationToSeconds,
+        }),
+    ],
+}).after({
+    delete: ["power", "trainingTime"],
+});
+exports.dragonPageTransformingModel = new transformer_1.TransformingModel({
+    id: [
+        (0, transformer_1.transform)({
+            key: "heading",
+            transformer: transformer_1.StringTransformer.extract(regex_helper_1.regexHelper.dragonId, 1),
+        }),
+        (0, transformer_1.transform)({
+            key: "id",
+            transformer: transformer_1.StringTransformer.toNumber,
+        }),
+    ],
+    name: [
+        (0, transformer_1.transform)({
+            key: "heading",
+            transformer: transformer_1.StringTransformer.extract(regex_helper_1.regexHelper.dragonName, 1),
+        }),
+    ],
+    name_key: [
+        (0, transformer_1.transform)({
+            key: "id",
+            transformer: (id) => `tid_unit_${id}_name`,
+        }),
+    ],
+    description: [
+        (0, transformer_1.transform)({
+            key: "description",
+            transformer: transformer_1.StringTransformer.trim,
+        }),
+    ],
+    description_key: [
+        (0, transformer_1.transform)({
+            key: "id",
+            transformer: (id) => `tid_unit_${id}_description`,
+        }),
+    ],
+    dragon_rarity: [
+        (0, transformer_1.transform)({
+            key: "rarity",
+            transformer: transformer_1.StringTransformer.toUpperCase,
+        }),
+        (0, transformer_1.transform)({
+            key: "dragon_rarity",
+            transformer: transformer_1.StringTransformer.substr(0, 1),
+        }),
+    ],
+    tempAttacks: [
+        (0, transformer_1.transform)({
+            key: "allAttacks",
+            transformer: transformer_1.ArrayTransformer.slice(0, 4),
+        }),
+    ],
+    attacks: {
+        key: "tempAttacks",
+        multiple: true,
+        model: attackTransformingModel,
+    },
+    attributes: [
+        (0, transformer_1.transform)({
+            key: "elements",
+            transformer: transformer_1.ArrayTransformer.map(transformer_1.StringTransformer.toLowerCase),
+        }),
+        (0, transformer_1.transform)({
+            key: "attributes",
+            transformer: (elements) => {
+                return elements.map((element) => dc_core_1.elementSettings[element].acronym);
+            },
+        }),
+    ],
+    tempTrainableAttacks: [
+        (0, transformer_1.transform)({
+            key: "allAttacks",
+            transformer: transformer_1.ArrayTransformer.slice(4, 8),
+        }),
+    ],
+    trainable_attacks: {
+        key: "tempTrainableAttacks",
+        multiple: true,
+        model: attackTransformingModel,
+    },
+    img_name: [
+        (0, transformer_1.transform)({
+            key: "firstImageUrl",
+            condition: (value) => !!value,
+            transformer: dc_core_1.DragonStaticFileUrlParser.getImageName,
+        }),
+        (0, transformer_1.transform)({
+            key: "firstImageUrl",
+            condition: (value) => !value,
+            transformer: () => null,
+        }),
+    ],
+    hatching_time: [
+        (0, transformer_1.transform)({
+            key: "hatchingTime",
+            condition: (value) => value !== null,
+            transformer: transformer_1.StringTransformer.trim,
+        }),
+        (0, transformer_1.transform)({
+            key: "hatching_time",
+            condition: (value) => value !== null,
+            transformer: utils_1.stringTimeToSeconds,
+        }),
+    ],
+    breeding_time: [
+        (0, transformer_1.transform)({
+            key: "breedingTime",
+            condition: (value) => value !== null,
+            transformer: transformer_1.StringTransformer.trim,
+        }),
+        (0, transformer_1.transform)({
+            key: "breeding_time",
+            condition: (value) => value !== null,
+            transformer: utils_1.stringTimeToSeconds,
+        }),
+    ],
+    xp: [
+        (0, transformer_1.transform)({
+            key: "xpOnHatching",
+            condition: (value) => !!value,
+            transformer: transformer_1.StringTransformer.replace(/,/g, ""),
+        }),
+        (0, transformer_1.transform)({
+            key: "xp",
+            condition: (value) => !!value,
+            transformer: transformer_1.StringTransformer.toNumber,
+        }),
+        (0, transformer_1.transform)({
+            key: "xp",
+            condition: (value) => !value,
+            transformer: () => null,
+        }),
+    ],
+    starting_coins: [
+        (0, transformer_1.transform)({
+            key: "goldProductionInfo",
+            condition: (value) => !!value,
+            transformer: transformer_1.StringTransformer.extract(regex_helper_1.regexHelper.dragonStartingCoins, 1),
+        }),
+        (0, transformer_1.transform)({
+            key: "starting_coins",
+            condition: (value) => !!value,
+            transformer: transformer_1.StringTransformer.toNumber,
+        }),
+        (0, transformer_1.transform)({
+            key: "goldProductionInfo",
+            condition: (value) => !value,
+            transformer: () => null,
+        }),
+    ],
+    coins_added: [
+        (0, transformer_1.transform)({
+            key: "goldProductionInfo",
+            condition: (value) => !!value,
+            transformer: transformer_1.StringTransformer.extract(regex_helper_1.regexHelper.dragonCoinsIncome, 1),
+        }),
+        (0, transformer_1.transform)({
+            key: "coins_added",
+            condition: (value) => !!value,
+            transformer: transformer_1.StringTransformer.toNumber,
+        }),
+        (0, transformer_1.transform)({
+            key: "goldProductionInfo",
+            condition: (value) => !value,
+            transformer: () => null,
+        }),
+    ],
+}).after({
+    delete: [
+        "heading",
+        "goldProductionInfo",
+        "hatchingExperience",
+        "xpOnHatching",
+        "firstImageUrl",
+        "elements",
+        "tempAttacks",
+        "allAttacks",
+        "tempTrainableAttacks",
+        "hatchingTime",
+        "breedingTime",
+    ],
+    append: {
+        group_type: "DRAGON",
+    },
+});

package/dist/transforming-models/dragon.model.d.ts

@@ -0,0 +1,2 @@
+import { TransformingModel } from "@xcrap/transformer";
+export declare const dragonTransformingModel: TransformingModel;