optolith-database-schema 0.15.3 → 0.15.5

package/lib/cache/activatableSelectOptions.js

@@ -0,0 +1,924 @@
+import { isNotNullish } from "../helpers/nullable.js";
+import { mapObject } from "../helpers/object.js";
+import { assertExhaustive } from "../helpers/typeSafety.js";
+const PRINCIPLES_ID = 31;
+const PROPERTY_KNOWLEDGE_ID = 3;
+const ASPECT_KNOWLEDGE_ID = 1;
+const matchesSpecificSkillishIdList = (id, config, equalsId) => {
+    switch (config.operation) {
+        case "Intersection":
+            return config.list.some(ref => equalsId(ref.id, id));
+        case "Difference":
+            return !config.list.some(ref => equalsId(ref.id, id));
+        default:
+            return assertExhaustive(config.operation);
+    }
+};
+const getSkillishPrerequisites = (ps, id) => {
+    if (ps === undefined) {
+        return undefined;
+    }
+    return ps.map(p => {
+        switch (p.tag) {
+            case "Self":
+                return {
+                    level: 1,
+                    prerequisite: {
+                        tag: "Single",
+                        single: {
+                            tag: "Rated",
+                            rated: {
+                                id,
+                                value: p.self.value,
+                            },
+                        },
+                    },
+                };
+            case "SelectOption":
+                return {
+                    level: 1,
+                    prerequisite: {
+                        tag: "Single",
+                        single: {
+                            tag: "Activatable",
+                            activatable: {
+                                id: p.select_option.id,
+                                active: p.select_option.active,
+                                level: p.select_option.level,
+                                options: [id],
+                            },
+                        },
+                    },
+                };
+            default:
+                return assertExhaustive(p);
+        }
+    });
+};
+const equalsSkillishIdGroup = (a, b) => {
+    switch (a.tag) {
+        case "Skill":
+            return b.tag === "Skill" && a.skill === b.skill;
+        case "Spell":
+            return b.tag === "Spell" && a.spell === b.spell;
+        case "Ritual":
+            return b.tag === "Ritual" && a.ritual === b.ritual;
+        case "LiturgicalChant":
+            return b.tag === "LiturgicalChant" && a.liturgical_chant === b.liturgical_chant;
+        case "Ceremony":
+            return b.tag === "Ceremony" && a.ceremony === b.ceremony;
+        case "CloseCombatTechnique":
+            return (b.tag === "CloseCombatTechnique" && a.close_combat_technique === b.close_combat_technique);
+        case "RangedCombatTechnique":
+            return (b.tag === "RangedCombatTechnique" && a.ranged_combat_technique === b.ranged_combat_technique);
+        default:
+            return assertExhaustive(a);
+    }
+};
+const getApValueForSkillish = (config, id, ic) => {
+    if (config === undefined) {
+        return undefined;
+    }
+    switch (config.tag) {
+        case "DerivedFromImprovementCost":
+            return ((() => {
+                switch (ic) {
+                    case "A":
+                        return 1;
+                    case "B":
+                        return 2;
+                    case "C":
+                        return 3;
+                    case "D":
+                        return 4;
+                    default:
+                        assertExhaustive(ic);
+                }
+            })() *
+                (config.derived_from_improvement_cost.multiplier ?? 1) +
+                (config.derived_from_improvement_cost.offset ?? 0));
+        case "Fixed":
+            return (config.fixed.map.find(mapping => equalsSkillishIdGroup(mapping.id, id))?.ap_value ??
+                config.fixed.default);
+        default:
+            return assertExhaustive(config);
+    }
+};
+const getDerivedSelectOptions = (selectOptionCategory, entryId, database) => {
+    switch (selectOptionCategory.tag) {
+        case "Blessings":
+            return database.blessings.map(([_, blessing]) => ({
+                id: { tag: "Blessing", blessing: blessing.id },
+                src: blessing.src,
+                translations: mapObject(blessing.translations, t10n => ({ name: t10n.name })),
+            }));
+        case "Cantrips":
+            return database.cantrips.map(([_, cantrip]) => ({
+                id: { tag: "Cantrip", cantrip: cantrip.id },
+                src: cantrip.src,
+                translations: mapObject(cantrip.translations, t10n => ({ name: t10n.name })),
+            }));
+        case "TradeSecrets":
+            return database.tradeSecrets.map(([_, tradeSecret]) => ({
+                id: { tag: "TradeSecret", trade_secret: tradeSecret.id },
+                prerequisites: tradeSecret.prerequisites,
+                ap_value: tradeSecret.ap_value,
+                src: tradeSecret.src,
+                translations: mapObject(tradeSecret.translations, t10n => ({
+                    name: t10n.name,
+                    errata: t10n.errata,
+                })),
+            }));
+        case "Scripts":
+            return database.scripts.map(([_, script]) => ({
+                id: { tag: "Script", script: script.id },
+                ap_value: script.ap_value,
+                src: script.src,
+                translations: mapObject(script.translations, t10n => ({
+                    name: t10n.name,
+                    errata: t10n.errata,
+                })),
+            }));
+        case "AnimalShapes": {
+            const pathsWithOrderedIds = database.animalShapePaths.reduce((acc, [id, _path]) => ({
+                ...acc,
+                [id]: database.animalShapes
+                    .toSorted(([_1, a], [_2, b]) => a.size.id - b.size.id)
+                    .map(([id]) => id),
+            }), {});
+            return database.animalShapes.map(([_, animalShape]) => {
+                const path = database.animalShapePaths.find(([id]) => id === animalShape.path.id)?.[1];
+                const size = database.animalShapeSizes.find(([id]) => id === animalShape.size.id)?.[1];
+                const pathIndex = path !== undefined ? pathsWithOrderedIds[path.id]?.indexOf(animalShape.id) ?? -1 : -1;
+                return {
+                    id: { tag: "AnimalShape", animal_shape: animalShape.id },
+                    prerequisites: pathIndex >= 0
+                        ? pathIndex === 0
+                            ? database.animalShapePaths
+                                .filter(([id]) => id !== animalShape.path.id && pathsWithOrderedIds[id]?.[0] !== undefined)
+                                .map(([id]) => ({
+                                level: 1,
+                                prerequisite: {
+                                    tag: "Single",
+                                    single: {
+                                        tag: "Activatable",
+                                        activatable: {
+                                            id: entryId,
+                                            active: false,
+                                            options: [
+                                                { tag: "AnimalShape", animal_shape: pathsWithOrderedIds[id][0] },
+                                            ],
+                                        },
+                                    },
+                                },
+                            }))
+                            : [
+                                {
+                                    level: 1,
+                                    prerequisite: {
+                                        tag: "Single",
+                                        single: {
+                                            tag: "Activatable",
+                                            activatable: {
+                                                id: entryId,
+                                                active: true,
+                                                options: [
+                                                    {
+                                                        tag: "AnimalShape",
+                                                        animal_shape: pathsWithOrderedIds[path.id][pathIndex - 1],
+                                                    },
+                                                ],
+                                            },
+                                        },
+                                    },
+                                },
+                            ]
+                        : undefined,
+                    volume: size?.volume,
+                    ap_value: size?.ap_value,
+                    translations: mapObject(animalShape.translations, (t10n, lang) => ({
+                        name: path?.translations[lang] !== undefined
+                            ? `${t10n.name} (${path.translations[lang].name})`
+                            : t10n.name,
+                    })),
+                };
+            });
+        }
+        case "ArcaneBardTraditions":
+            return database.arcaneBardTraditions.map(([_, arcaneBardTradition]) => ({
+                id: { tag: "ArcaneBardTradition", arcane_bard_tradition: arcaneBardTradition.id },
+                prerequisites: arcaneBardTradition.prerequisites.map(p => ({
+                    level: 1,
+                    prerequisite: p,
+                })),
+                translations: mapObject(arcaneBardTradition.translations, t10n => ({
+                    name: t10n.name,
+                })),
+            }));
+        case "ArcaneDancerTraditions":
+            return database.arcaneDancerTraditions.map(([_, arcaneDancerTradition]) => ({
+                id: { tag: "ArcaneDancerTradition", arcane_dancer_tradition: arcaneDancerTradition.id },
+                prerequisites: arcaneDancerTradition.prerequisites.map(p => ({
+                    level: 1,
+                    prerequisite: p,
+                })),
+                translations: mapObject(arcaneDancerTradition.translations, t10n => ({
+                    name: t10n.name,
+                })),
+            }));
+        case "SexPractices":
+            return database.sexPractices.map(([_, sexPractice]) => ({
+                id: { tag: "SexPractice", sex_practice: sexPractice.id },
+                src: sexPractice.src,
+                translations: mapObject(sexPractice.translations, t10n => ({
+                    name: t10n.name,
+                })),
+            }));
+        case "Races":
+            return database.races.map(([_, race]) => ({
+                id: { tag: "Race", race: race.id },
+                src: race.src,
+                translations: mapObject(race.translations, t10n => ({
+                    name: t10n.name,
+                })),
+            }));
+        case "Cultures":
+            return database.cultures.map(([_, culture]) => ({
+                id: { tag: "Culture", culture: culture.id },
+                src: culture.src,
+                translations: mapObject(culture.translations, t10n => ({
+                    name: t10n.name,
+                })),
+            }));
+        case "RacesAndCultures":
+            return [
+                ...database.races.map(([_, race]) => ({
+                    id: { tag: "Race", race: race.id },
+                    src: race.src,
+                    translations: mapObject(race.translations, t10n => ({
+                        name: t10n.name,
+                    })),
+                })),
+                ...database.cultures.map(([_, culture]) => ({
+                    id: { tag: "Culture", culture: culture.id },
+                    src: culture.src,
+                    translations: mapObject(culture.translations, t10n => ({
+                        name: t10n.name,
+                    })),
+                })),
+            ];
+        case "BlessedTraditions": {
+            const getPrerequisites = (blessedTradition) => {
+                if (selectOptionCategory.blessed_traditions.require_principles &&
+                    blessedTradition.associated_principles_id !== undefined) {
+                    return [
+                        {
+                            level: 1,
+                            prerequisite: {
+                                tag: "Single",
+                                single: {
+                                    tag: "Activatable",
+                                    activatable: {
+                                        id: { tag: "Disadvantage", disadvantage: PRINCIPLES_ID },
+                                        active: true,
+                                        options: [
+                                            { tag: "General", general: blessedTradition.associated_principles_id },
+                                        ],
+                                    },
+                                },
+                            },
+                        },
+                    ];
+                }
+            };
+            return database.blessedTraditions.map(([_, blessedTradition]) => ({
+                id: { tag: "BlessedTradition", blessed_tradition: blessedTradition.id },
+                prerequisites: getPrerequisites(blessedTradition),
+                src: blessedTradition.src,
+                translations: mapObject(blessedTradition.translations, t10n => ({
+                    name: t10n.name,
+                })),
+            }));
+        }
+        case "Elements": {
+            const mapToResolvedSelectOption = ([_, element]) => ({
+                id: { tag: "Element", element: element.id },
+                translations: mapObject(element.translations, t10n => ({
+                    name: t10n.name,
+                })),
+            });
+            if (selectOptionCategory.elements.specific) {
+                return database.elements
+                    .filter(([id]) => selectOptionCategory.elements.specific.some(ref => ref.id.element === id))
+                    .map(mapToResolvedSelectOption);
+            }
+            return database.elements.map(mapToResolvedSelectOption);
+        }
+        case "Properties": {
+            const getPrerequisites = (property) => {
+                if (selectOptionCategory.properties.require_knowledge !== undefined ||
+                    selectOptionCategory.properties.require_minimum_spellworks_on !== undefined) {
+                    const knowledgePrerequisite = selectOptionCategory.properties.require_knowledge !== undefined
+                        ? {
+                            level: 1,
+                            prerequisite: {
+                                tag: "Single",
+                                single: {
+                                    tag: "Activatable",
+                                    activatable: {
+                                        id: {
+                                            tag: "MagicalSpecialAbility",
+                                            magical_special_ability: PROPERTY_KNOWLEDGE_ID,
+                                        },
+                                        active: true,
+                                        options: [{ tag: "Property", property: property.id }],
+                                    },
+                                },
+                            },
+                        }
+                        : undefined;
+                    const minimumSpellworksPrerequisite = selectOptionCategory.properties.require_minimum_spellworks_on !== undefined
+                        ? {
+                            level: 1,
+                            prerequisite: {
+                                tag: "Single",
+                                single: {
+                                    tag: "RatedMinimumNumber",
+                                    rated_minimum_number: {
+                                        number: selectOptionCategory.properties.require_minimum_spellworks_on.number,
+                                        value: selectOptionCategory.properties.require_minimum_spellworks_on.rating,
+                                        targets: {
+                                            tag: "Spellworks",
+                                            spellworks: {
+                                                id: { tag: "Property", property: property.id },
+                                            },
+                                        },
+                                    },
+                                },
+                            },
+                        }
+                        : undefined;
+                    return [knowledgePrerequisite, minimumSpellworksPrerequisite].filter(isNotNullish);
+                }
+            };
+            return database.properties.map(([_, property]) => ({
+                id: { tag: "Property", property: property.id },
+                prerequisites: getPrerequisites(property),
+                translations: mapObject(property.translations, t10n => ({
+                    name: t10n.name,
+                })),
+            }));
+        }
+        case "Aspects": {
+            const getPrerequisites = (aspect) => {
+                if (selectOptionCategory.aspects.require_knowledge !== undefined ||
+                    selectOptionCategory.aspects.require_minimum_liturgies_on !== undefined) {
+                    const knowledgePrerequisite = selectOptionCategory.aspects.require_knowledge !== undefined
+                        ? {
+                            level: 1,
+                            prerequisite: {
+                                tag: "Single",
+                                single: {
+                                    tag: "Activatable",
+                                    activatable: {
+                                        id: {
+                                            tag: "KarmaSpecialAbility",
+                                            karma_special_ability: ASPECT_KNOWLEDGE_ID,
+                                        },
+                                        active: true,
+                                        options: [{ tag: "Property", property: aspect.id }],
+                                    },
+                                },
+                            },
+                        }
+                        : undefined;
+                    const minimumSpellworksPrerequisite = selectOptionCategory.aspects.require_minimum_liturgies_on !== undefined
+                        ? {
+                            level: 1,
+                            prerequisite: {
+                                tag: "Single",
+                                single: {
+                                    tag: "RatedMinimumNumber",
+                                    rated_minimum_number: {
+                                        number: selectOptionCategory.aspects.require_minimum_liturgies_on.number,
+                                        value: selectOptionCategory.aspects.require_minimum_liturgies_on.rating,
+                                        targets: {
+                                            tag: "Liturgies",
+                                            liturgies: {
+                                                id: { tag: "Aspect", aspect: aspect.id },
+                                            },
+                                        },
+                                    },
+                                },
+                            },
+                        }
+                        : undefined;
+                    return [knowledgePrerequisite, minimumSpellworksPrerequisite].filter(isNotNullish);
+                }
+            };
+            if (selectOptionCategory.aspects.use_master_of_suffix_as_name === true) {
+                return database.aspects
+                    .map(([_, aspect]) => ({
+                    id: { tag: "Aspect", aspect: aspect.id },
+                    prerequisites: getPrerequisites(aspect),
+                    translations: mapObject(aspect.translations, t10n => t10n.master_of_aspect_suffix === undefined
+                        ? undefined
+                        : {
+                            name: t10n.master_of_aspect_suffix,
+                        }),
+                }))
+                    .filter(value => Object.keys(value.translations).length > 0);
+            }
+            return database.aspects.map(([_, aspect]) => ({
+                id: { tag: "Aspect", aspect: aspect.id },
+                prerequisites: getPrerequisites(aspect),
+                translations: mapObject(aspect.translations, t10n => ({
+                    name: t10n.name,
+                })),
+            }));
+        }
+        case "Diseases":
+            return database.diseases.map(([_, disease]) => ({
+                id: { tag: "Disease", disease: disease.id },
+                ap_value: selectOptionCategory.diseases.use_half_level_as_ap_value === true
+                    ? Math.round(disease.level / 3)
+                    : disease.level,
+                src: disease.src,
+                translations: mapObject(disease.translations, t10n => ({
+                    name: t10n.name,
+                })),
+            }));
+        case "Poisons": {
+            const getLevel = (poison) => {
+                switch (poison.source_type.tag) {
+                    case "AnimalVenom":
+                        return poison.source_type.animal_venom.level;
+                    case "AlchemicalPoison":
+                        return 6;
+                    case "MineralPoison":
+                        return poison.source_type.mineral_poison.level;
+                    case "PlantPoison":
+                        return poison.source_type.plant_poison.level;
+                    case "DemonicPoison":
+                        switch (poison.source_type.demonic_poison.level.tag) {
+                            case "Constant":
+                                return poison.source_type.demonic_poison.level.constant.value;
+                            case "QualityLevel":
+                                return 6;
+                            default:
+                                return assertExhaustive(poison.source_type.demonic_poison.level);
+                        }
+                    default:
+                        return assertExhaustive(poison.source_type);
+                }
+            };
+            return database.poisons.map(([_, poison]) => ({
+                id: { tag: "Poison", poison: poison.id },
+                ap_value: selectOptionCategory.poisons.use_half_level_as_ap_value === true
+                    ? Math.round(getLevel(poison) / 3)
+                    : getLevel(poison),
+                src: poison.src,
+                translations: mapObject(poison.translations, t10n => ({
+                    name: t10n.name,
+                })),
+            }));
+        }
+        case "Languages": {
+            const getPrerequisites = (language) => {
+                if (selectOptionCategory.languages.prerequisites !== undefined) {
+                    return selectOptionCategory.languages.prerequisites.map(config => ({
+                        level: 1,
+                        prerequisite: {
+                            tag: "Single",
+                            single: {
+                                tag: "Activatable",
+                                activatable: {
+                                    id: config.select_option.id,
+                                    active: config.select_option.active,
+                                    level: config.select_option.level,
+                                    options: [{ tag: "Language", language: language.id }],
+                                },
+                            },
+                        },
+                    }));
+                }
+            };
+            return database.languages.map(([_, language]) => ({
+                id: { tag: "Language", language: language.id },
+                prerequisites: getPrerequisites(language),
+                src: language.src,
+                translations: mapObject(language.translations, t10n => ({
+                    name: t10n.name,
+                })),
+            }));
+        }
+        case "Skills": {
+            const apValueGen = selectOptionCategory.skills.ap_value;
+            return selectOptionCategory.skills.categories.flatMap(category => {
+                switch (category.tag) {
+                    case "Skills":
+                        return database.skills
+                            .filter(([_, skill]) => {
+                            const matchesGroupRequirement = category.skills.groups === undefined ||
+                                category.skills.groups.some(ref => ref.id.skill_group === skill.group.id.skill_group);
+                            const matchesIdRequirement = category.skills.specific === undefined ||
+                                matchesSpecificSkillishIdList({ tag: "Skill", skill: skill.id }, category.skills.specific, equalsSkillishIdGroup);
+                            return matchesGroupRequirement && matchesIdRequirement;
+                        })
+                            .map(([_, skill]) => {
+                            const id = { tag: "Skill", skill: skill.id };
+                            return {
+                                id,
+                                skill_uses: category.skills.skill_uses?.map(use => ({
+                                    id: use.id,
+                                    skill: { tag: "Single", single: { id } },
+                                    translations: use.translations,
+                                })),
+                                skill_applications: category.skills.skill_applications?.map(use => ({
+                                    id: use.id,
+                                    skill: { tag: "Single", single: { id } },
+                                    translations: use.translations,
+                                })),
+                                prerequisites: getSkillishPrerequisites(category.skills.prerequisites, id),
+                                ap_value: getApValueForSkillish(category.skills.ap_value ?? apValueGen, id, skill.improvement_cost),
+                                src: skill.src,
+                                translations: mapObject(skill.translations, t10n => ({
+                                    name: t10n.name,
+                                })),
+                            };
+                        });
+                    case "Spells":
+                        return database.spells
+                            .filter(([_, spell]) => category.spells.specific === undefined ||
+                            matchesSpecificSkillishIdList({ tag: "Spell", spell: spell.id }, category.spells.specific, equalsSkillishIdGroup))
+                            .map(([_, spell]) => {
+                            const id = { tag: "Spell", spell: spell.id };
+                            return {
+                                id,
+                                prerequisites: getSkillishPrerequisites(category.spells.prerequisites, id),
+                                ap_value: getApValueForSkillish(apValueGen, id, spell.improvement_cost),
+                                src: spell.src,
+                                translations: mapObject(spell.translations, t10n => ({
+                                    name: t10n.name,
+                                })),
+                            };
+                        });
+                    case "Rituals":
+                        return database.rituals
+                            .filter(([_, ritual]) => category.rituals.specific === undefined ||
+                            matchesSpecificSkillishIdList({ tag: "Ritual", ritual: ritual.id }, category.rituals.specific, equalsSkillishIdGroup))
+                            .map(([_, ritual]) => {
+                            const id = { tag: "Ritual", ritual: ritual.id };
+                            return {
+                                id,
+                                prerequisites: getSkillishPrerequisites(category.rituals.prerequisites, id),
+                                ap_value: getApValueForSkillish(apValueGen, id, ritual.improvement_cost),
+                                src: ritual.src,
+                                translations: mapObject(ritual.translations, t10n => ({
+                                    name: t10n.name,
+                                })),
+                            };
+                        });
+                    case "LiturgicalChants":
+                        return database.liturgicalChants
+                            .filter(([_, liturgicalChant]) => category.liturgical_chants.specific === undefined ||
+                            matchesSpecificSkillishIdList({ tag: "LiturgicalChant", liturgical_chant: liturgicalChant.id }, category.liturgical_chants.specific, equalsSkillishIdGroup))
+                            .map(([_, liturgicalChant]) => {
+                            const id = {
+                                tag: "LiturgicalChant",
+                                liturgical_chant: liturgicalChant.id,
+                            };
+                            return {
+                                id,
+                                prerequisites: getSkillishPrerequisites(category.liturgical_chants.prerequisites, id),
+                                ap_value: getApValueForSkillish(apValueGen, id, liturgicalChant.improvement_cost),
+                                src: liturgicalChant.src,
+                                translations: mapObject(liturgicalChant.translations, t10n => ({
+                                    name: t10n.name,
+                                })),
+                            };
+                        });
+                    case "Ceremonies":
+                        return database.ceremonies
+                            .filter(([_, ceremony]) => category.ceremonies.specific === undefined ||
+                            matchesSpecificSkillishIdList({ tag: "Ceremony", ceremony: ceremony.id }, category.ceremonies.specific, equalsSkillishIdGroup))
+                            .map(([_, ceremony]) => {
+                            const id = { tag: "Ceremony", ceremony: ceremony.id };
+                            return {
+                                id,
+                                prerequisites: getSkillishPrerequisites(category.ceremonies.prerequisites, id),
+                                ap_value: getApValueForSkillish(apValueGen, id, ceremony.improvement_cost),
+                                src: ceremony.src,
+                                translations: mapObject(ceremony.translations, t10n => ({
+                                    name: t10n.name,
+                                })),
+                            };
+                        });
+                    default:
+                        return assertExhaustive(category);
+                }
+            });
+        }
+        case "CombatTechniques": {
+            const apValueGen = selectOptionCategory.combat_techniques.ap_value;
+            return selectOptionCategory.combat_techniques.categories.flatMap(category => {
+                switch (category.tag) {
+                    case "CloseCombatTechniques":
+                        return database.closeCombatTechniques
+                            .filter(([_, closeCombatTechnique]) => category.close_combat_techniques.specific === undefined ||
+                            matchesSpecificSkillishIdList({
+                                tag: "CloseCombatTechnique",
+                                close_combat_technique: closeCombatTechnique.id,
+                            }, category.close_combat_techniques.specific, equalsSkillishIdGroup))
+                            .map(([_, closeCombatTechnique]) => {
+                            const id = {
+                                tag: "CloseCombatTechnique",
+                                close_combat_technique: closeCombatTechnique.id,
+                            };
+                            return {
+                                id,
+                                prerequisites: getSkillishPrerequisites(category.close_combat_techniques.prerequisites, id),
+                                ap_value: getApValueForSkillish(apValueGen, id, closeCombatTechnique.improvement_cost),
+                                src: closeCombatTechnique.src,
+                                translations: mapObject(closeCombatTechnique.translations, t10n => ({
+                                    name: t10n.name,
+                                })),
+                            };
+                        });
+                    case "RangedCombatTechniques":
+                        return database.rangedCombatTechniques
+                            .filter(([_, rangedCombatTechnique]) => category.ranged_combat_techniques.specific === undefined ||
+                            matchesSpecificSkillishIdList({
+                                tag: "RangedCombatTechnique",
+                                ranged_combat_technique: rangedCombatTechnique.id,
+                            }, category.ranged_combat_techniques.specific, equalsSkillishIdGroup))
+                            .map(([_, rangedCombatTechnique]) => {
+                            const id = {
+                                tag: "RangedCombatTechnique",
+                                ranged_combat_technique: rangedCombatTechnique.id,
+                            };
+                            return {
+                                id,
+                                prerequisites: getSkillishPrerequisites(category.ranged_combat_techniques.prerequisites, id),
+                                ap_value: getApValueForSkillish(apValueGen, id, rangedCombatTechnique.improvement_cost),
+                                src: rangedCombatTechnique.src,
+                                translations: mapObject(rangedCombatTechnique.translations, t10n => ({
+                                    name: t10n.name,
+                                })),
+                            };
+                        });
+                    default:
+                        return assertExhaustive(category);
+                }
+            });
+        }
+        case "TargetCategories": {
+            const mapToResolvedSelectOption = (targetCategory, specificTargetCategory) => ({
+                id: { tag: "TargetCategory", target_category: targetCategory.id },
+                volume: specificTargetCategory?.volume,
+                translations: mapObject(targetCategory.translations, t10n => ({
+                    name: t10n.name,
+                })),
+            });
+            if (selectOptionCategory.target_categories.list) {
+                return database.targetCategories
+                    .filter(([id]) => selectOptionCategory.target_categories.list.some(ref => ref.id.target_category === id))
+                    .map(([id, targetCategory]) => mapToResolvedSelectOption(targetCategory, selectOptionCategory.target_categories.list.find(ref => ref.id.target_category === id)));
+            }
+            return database.targetCategories.map(p => mapToResolvedSelectOption(p[1]));
+        }
+        default:
+            return assertExhaustive(selectOptionCategory);
+    }
+};
+const getExplicitSelectOptions = (explicitSelectOptions, database) => explicitSelectOptions
+    .map((explicitSelectOption) => {
+    switch (explicitSelectOption.tag) {
+        case "General":
+            return {
+                id: { tag: "Generic", generic: explicitSelectOption.general.id },
+                translations: explicitSelectOption.general.translations,
+            };
+        case "Skill": {
+            const skill = database.skills.find(p => p[0] === explicitSelectOption.skill.id.skill)?.[1];
+            if (skill === undefined) {
+                return undefined;
+            }
+            return {
+                id: { tag: "Skill", skill: explicitSelectOption.skill.id.skill },
+                translations: mapObject(skill.translations, t10n => ({ name: t10n.name })),
+            };
+        }
+        case "CombatTechnique":
+            switch (explicitSelectOption.combat_technique.id.tag) {
+                case "CloseCombatTechnique": {
+                    const id = explicitSelectOption.combat_technique.id.close_combat_technique;
+                    const closeCombatTechnique = database.closeCombatTechniques.find(p => p[0] === id)?.[1];
+                    if (closeCombatTechnique === undefined) {
+                        return undefined;
+                    }
+                    return {
+                        id: { tag: "CloseCombatTechnique", close_combat_technique: id },
+                        translations: mapObject(closeCombatTechnique.translations, t10n => ({
+                            name: t10n.name,
+                        })),
+                    };
+                }
+                case "RangedCombatTechnique": {
+                    const id = explicitSelectOption.combat_technique.id.ranged_combat_technique;
+                    const rangedCombatTechnique = database.rangedCombatTechniques.find(p => p[0] === id)?.[1];
+                    if (rangedCombatTechnique === undefined) {
+                        return undefined;
+                    }
+                    return {
+                        id: { tag: "RangedCombatTechnique", ranged_combat_technique: id },
+                        translations: mapObject(rangedCombatTechnique.translations, t10n => ({
+                            name: t10n.name,
+                        })),
+                    };
+                }
+                default:
+                    return assertExhaustive(explicitSelectOption.combat_technique.id);
+            }
+        default:
+            return assertExhaustive(explicitSelectOption);
+    }
+})
+    .filter(isNotNullish);
+const getSelectOptions = (selectOptions, id, database) => [
+    ...(selectOptions.derived === undefined
+        ? []
+        : getDerivedSelectOptions(selectOptions.derived, id, database)),
+    ...(selectOptions.explicit === undefined
+        ? []
+        : getExplicitSelectOptions(selectOptions.explicit, database)),
+];
+const getSelectOptionsForResults = (database, idTag, results) => results.reduce((acc, [id, data]) => {
+    const options = getSelectOptions(data.select_options ?? {}, (() => {
+        switch (idTag) {
+            case "Advantage":
+                return { tag: "Advantage", advantage: id };
+            case "Disadvantage":
+                return { tag: "Disadvantage", disadvantage: id };
+            case "GeneralSpecialAbility":
+                return { tag: "GeneralSpecialAbility", general_special_ability: id };
+            case "FatePointSpecialAbility":
+                return { tag: "FatePointSpecialAbility", fate_point_special_ability: id };
+            case "CombatSpecialAbility":
+                return { tag: "CombatSpecialAbility", combat_special_ability: id };
+            case "MagicalSpecialAbility":
+                return { tag: "MagicalSpecialAbility", magical_special_ability: id };
+            case "StaffEnchantment":
+                return { tag: "StaffEnchantment", staff_enchantment: id };
+            case "FamiliarSpecialAbility":
+                return { tag: "FamiliarSpecialAbility", familiar_special_ability: id };
+            case "KarmaSpecialAbility":
+                return { tag: "KarmaSpecialAbility", karma_special_ability: id };
+            case "ProtectiveWardingCircleSpecialAbility":
+                return {
+                    tag: "ProtectiveWardingCircleSpecialAbility",
+                    protective_warding_circle_special_ability: id,
+                };
+            case "CombatStyleSpecialAbility":
+                return { tag: "CombatStyleSpecialAbility", combat_style_special_ability: id };
+            case "AdvancedCombatSpecialAbility":
+                return { tag: "AdvancedCombatSpecialAbility", advanced_combat_special_ability: id };
+            case "CommandSpecialAbility":
+                return { tag: "CommandSpecialAbility", command_special_ability: id };
+            case "MagicStyleSpecialAbility":
+                return { tag: "MagicStyleSpecialAbility", magic_style_special_ability: id };
+            case "AdvancedMagicalSpecialAbility":
+                return { tag: "AdvancedMagicalSpecialAbility", advanced_magical_special_ability: id };
+            case "SpellSwordEnchantment":
+                return { tag: "SpellSwordEnchantment", spell_sword_enchantment: id };
+            case "DaggerRitual":
+                return { tag: "DaggerRitual", dagger_ritual: id };
+            case "InstrumentEnchantment":
+                return { tag: "InstrumentEnchantment", instrument_enchantment: id };
+            case "AttireEnchantment":
+                return { tag: "AttireEnchantment", attire_enchantment: id };
+            case "OrbEnchantment":
+                return { tag: "OrbEnchantment", orb_enchantment: id };
+            case "WandEnchantment":
+                return { tag: "WandEnchantment", wand_enchantment: id };
+            case "BrawlingSpecialAbility":
+                return { tag: "BrawlingSpecialAbility", brawling_special_ability: id };
+            case "AncestorGlyph":
+                return { tag: "AncestorGlyph", ancestor_glyph: id };
+            case "CeremonialItemSpecialAbility":
+                return { tag: "CeremonialItemSpecialAbility", ceremonial_item_special_ability: id };
+            case "Sermon":
+                return { tag: "Sermon", sermon: id };
+            case "LiturgicalStyleSpecialAbility":
+                return { tag: "LiturgicalStyleSpecialAbility", liturgical_style_special_ability: id };
+            case "AdvancedKarmaSpecialAbility":
+                return { tag: "AdvancedKarmaSpecialAbility", advanced_karma_special_ability: id };
+            case "Vision":
+                return { tag: "Vision", vision: id };
+            case "MagicalTradition":
+                return { tag: "MagicalTradition", magical_tradition: id };
+            case "BlessedTradition":
+                return { tag: "BlessedTradition", blessed_tradition: id };
+            case "PactGift":
+                return { tag: "PactGift", pact_gift: id };
+            case "SikaryanDrainSpecialAbility":
+                return { tag: "SikaryanDrainSpecialAbility", sikaryan_drain_special_ability: id };
+            case "VampiricGift":
+                return { tag: "VampiricGift", vampiric_gift: id };
+            case "LycantropicGift":
+                return { tag: "LycantropicGift", lycantropic_gift: id };
+            case "SkillStyleSpecialAbility":
+                return { tag: "SkillStyleSpecialAbility", skill_style_special_ability: id };
+            case "AdvancedSkillSpecialAbility":
+                return { tag: "AdvancedSkillSpecialAbility", advanced_skill_special_ability: id };
+            case "ArcaneOrbEnchantment":
+                return { tag: "ArcaneOrbEnchantment", arcane_orb_enchantment: id };
+            case "CauldronEnchantment":
+                return { tag: "CauldronEnchantment", cauldron_enchantment: id };
+            case "FoolsHatEnchantment":
+                return { tag: "FoolsHatEnchantment", fools_hat_enchantment: id };
+            case "ToyEnchantment":
+                return { tag: "ToyEnchantment", toy_enchantment: id };
+            case "BowlEnchantment":
+                return { tag: "BowlEnchantment", bowl_enchantment: id };
+            case "FatePointSexSpecialAbility":
+                return { tag: "FatePointSexSpecialAbility", fate_point_sex_special_ability: id };
+            case "SexSpecialAbility":
+                return { tag: "SexSpecialAbility", sex_special_ability: id };
+            case "WeaponEnchantment":
+                return { tag: "WeaponEnchantment", weapon_enchantment: id };
+            case "SickleRitual":
+                return { tag: "SickleRitual", sickle_ritual: id };
+            case "RingEnchantment":
+                return { tag: "RingEnchantment", ring_enchantment: id };
+            case "ChronicleEnchantment":
+                return { tag: "ChronicleEnchantment", chronicle_enchantment: id };
+            case "Krallenkettenzauber":
+                return { tag: "Krallenkettenzauber", krallenkettenzauber: id };
+            case "Trinkhornzauber":
+                return { tag: "Trinkhornzauber", trinkhornzauber: id };
+            default:
+                return assertExhaustive(idTag);
+        }
+    })(), database);
+    if (options.length > 0) {
+        acc[id] = options;
+    }
+    return acc;
+}, {});
+// prettier-ignore
+export const config = {
+    builder(database) {
+        return {
+            advancedCombatSpecialAbilities: getSelectOptionsForResults(database, "AdvancedCombatSpecialAbility", database.advancedCombatSpecialAbilities),
+            advancedKarmaSpecialAbilities: getSelectOptionsForResults(database, "AdvancedKarmaSpecialAbility", database.advancedKarmaSpecialAbilities),
+            advancedMagicalSpecialAbilities: getSelectOptionsForResults(database, "AdvancedMagicalSpecialAbility", database.advancedMagicalSpecialAbilities),
+            advancedSkillSpecialAbilities: getSelectOptionsForResults(database, "AdvancedSkillSpecialAbility", database.advancedSkillSpecialAbilities),
+            advantages: getSelectOptionsForResults(database, "Advantage", database.advantages),
+            ancestorGlyphs: getSelectOptionsForResults(database, "AncestorGlyph", database.ancestorGlyphs),
+            arcaneOrbEnchantments: getSelectOptionsForResults(database, "ArcaneOrbEnchantment", database.arcaneOrbEnchantments),
+            attireEnchantments: getSelectOptionsForResults(database, "AttireEnchantment", database.attireEnchantments),
+            blessedTraditions: getSelectOptionsForResults(database, "BlessedTradition", database.blessedTraditions),
+            bowlEnchantments: getSelectOptionsForResults(database, "BowlEnchantment", database.bowlEnchantments),
+            brawlingSpecialAbilities: getSelectOptionsForResults(database, "BrawlingSpecialAbility", database.brawlingSpecialAbilities),
+            cauldronEnchantments: getSelectOptionsForResults(database, "CauldronEnchantment", database.cauldronEnchantments),
+            ceremonialItemSpecialAbilities: getSelectOptionsForResults(database, "CeremonialItemSpecialAbility", database.ceremonialItemSpecialAbilities),
+            chronicleEnchantments: getSelectOptionsForResults(database, "ChronicleEnchantment", database.chronicleEnchantments),
+            combatSpecialAbilities: getSelectOptionsForResults(database, "CombatSpecialAbility", database.combatSpecialAbilities),
+            combatStyleSpecialAbilities: getSelectOptionsForResults(database, "CombatStyleSpecialAbility", database.combatStyleSpecialAbilities),
+            commandSpecialAbilities: getSelectOptionsForResults(database, "CommandSpecialAbility", database.commandSpecialAbilities),
+            daggerRituals: getSelectOptionsForResults(database, "DaggerRitual", database.daggerRituals),
+            disadvantages: getSelectOptionsForResults(database, "Disadvantage", database.disadvantages),
+            familiarSpecialAbilities: getSelectOptionsForResults(database, "FamiliarSpecialAbility", database.familiarSpecialAbilities),
+            fatePointSexSpecialAbilities: getSelectOptionsForResults(database, "FatePointSexSpecialAbility", database.fatePointSexSpecialAbilities),
+            fatePointSpecialAbilities: getSelectOptionsForResults(database, "FatePointSpecialAbility", database.fatePointSpecialAbilities),
+            foolsHatEnchantments: getSelectOptionsForResults(database, "FoolsHatEnchantment", database.foolsHatEnchantments),
+            generalSpecialAbilities: getSelectOptionsForResults(database, "GeneralSpecialAbility", database.generalSpecialAbilities),
+            instrumentEnchantments: getSelectOptionsForResults(database, "InstrumentEnchantment", database.instrumentEnchantments),
+            karmaSpecialAbilities: getSelectOptionsForResults(database, "KarmaSpecialAbility", database.karmaSpecialAbilities),
+            krallenkettenzauber: getSelectOptionsForResults(database, "Krallenkettenzauber", database.krallenkettenzauber),
+            liturgicalStyleSpecialAbilities: getSelectOptionsForResults(database, "LiturgicalStyleSpecialAbility", database.liturgicalStyleSpecialAbilities),
+            lycantropicGifts: getSelectOptionsForResults(database, "LycantropicGift", database.lycantropicGifts),
+            magicalSpecialAbilities: getSelectOptionsForResults(database, "MagicalSpecialAbility", database.magicalSpecialAbilities),
+            magicalTraditions: getSelectOptionsForResults(database, "MagicalTradition", database.magicalTraditions),
+            magicStyleSpecialAbilities: getSelectOptionsForResults(database, "MagicStyleSpecialAbility", database.magicStyleSpecialAbilities),
+            orbEnchantments: getSelectOptionsForResults(database, "OrbEnchantment", database.orbEnchantments),
+            pactGifts: getSelectOptionsForResults(database, "PactGift", database.pactGifts),
+            protectiveWardingCircleSpecialAbilities: getSelectOptionsForResults(database, "ProtectiveWardingCircleSpecialAbility", database.protectiveWardingCircleSpecialAbilities),
+            ringEnchantments: getSelectOptionsForResults(database, "RingEnchantment", database.ringEnchantments),
+            sermons: getSelectOptionsForResults(database, "Sermon", database.sermons),
+            sexSpecialAbilities: getSelectOptionsForResults(database, "SexSpecialAbility", database.sexSpecialAbilities),
+            sickleRituals: getSelectOptionsForResults(database, "SickleRitual", database.sickleRituals),
+            sikaryanDrainSpecialAbilities: getSelectOptionsForResults(database, "SikaryanDrainSpecialAbility", database.sikaryanDrainSpecialAbilities),
+            staffEnchantments: getSelectOptionsForResults(database, "StaffEnchantment", database.staffEnchantments),
+            skillStyleSpecialAbilities: getSelectOptionsForResults(database, "SkillStyleSpecialAbility", database.skillStyleSpecialAbilities),
+            spellSwordEnchantments: getSelectOptionsForResults(database, "SpellSwordEnchantment", database.spellSwordEnchantments),
+            toyEnchantments: getSelectOptionsForResults(database, "ToyEnchantment", database.toyEnchantments),
+            trinkhornzauber: getSelectOptionsForResults(database, "Trinkhornzauber", database.trinkhornzauber),
+            vampiricGifts: getSelectOptionsForResults(database, "VampiricGift", database.vampiricGifts),
+            visions: getSelectOptionsForResults(database, "Vision", database.visions),
+            wandEnchantments: getSelectOptionsForResults(database, "WandEnchantment", database.wandEnchantments),
+            weaponEnchantments: getSelectOptionsForResults(database, "WeaponEnchantment", database.weaponEnchantments),
+        };
+    },
+};