optolith-database-schema 0.17.2 → 0.18.1

package/lib/cache/ancestorBloodAdvantages.d.ts

@@ -1,5 +0,0 @@
-import type { CacheConfig } from "../cacheConfig.js";
-export type AncestorBloodAdvantagesCache = {
-    ids: number[];
-};
-export declare const config: CacheConfig<AncestorBloodAdvantagesCache>;

package/lib/cache/ancestorBloodAdvantages.js

@@ -1,18 +0,0 @@
-export const config = {
-    builder(database) {
-        return {
-            ids: database.advantages
-                .filter(([id, advantage]) => advantage.prerequisites?.some(p => {
-                switch (p.prerequisite.tag) {
-                    case "Single":
-                        return p.prerequisite.single.tag === "NoOtherAncestorBloodAdvantage";
-                    case "Disjunction":
-                        return p.prerequisite.disjunction.list.some(d => d.tag === "NoOtherAncestorBloodAdvantage");
-                    case "Group":
-                        return p.prerequisite.group.list.some(g => g.tag === "NoOtherAncestorBloodAdvantage");
-                }
-            }))
-                .map(([id]) => id),
-        };
-    },
-};

package/lib/cache/magicalAndBlessedAdvantagesAndDisadvantages.d.ts

@@ -1,20 +0,0 @@
-import type { CacheConfig } from "../cacheConfig.js";
-export type MagicalAndBlessedAdvantagesAndDisadvantagesCache = {
-    advantages: {
-        magical: {
-            ids: number[];
-        };
-        blessed: {
-            ids: number[];
-        };
-    };
-    disadvantages: {
-        magical: {
-            ids: number[];
-        };
-        blessed: {
-            ids: number[];
-        };
-    };
-};
-export declare const config: CacheConfig<MagicalAndBlessedAdvantagesAndDisadvantagesCache>;

package/lib/cache/magicalAndBlessedAdvantagesAndDisadvantages.js

@@ -1,164 +0,0 @@
-import { assertExhaustive } from "@optolith/helpers/typeSafety";
-const BLESSED_ID = 12;
-const SPELLCASTER_ID = 47;
-const getAdvantageId = (type) => {
-    switch (type) {
-        case "Magical":
-            return SPELLCASTER_ID;
-        case "Blessed":
-            return BLESSED_ID;
-        default:
-            return assertExhaustive(type);
-    }
-};
-const isRatedFor = (type, ratedId) => {
-    switch (ratedId.tag) {
-        case "Spell":
-        case "Ritual":
-            return type === "Magical";
-        case "LiturgicalChant":
-        case "Ceremony":
-            return type === "Blessed";
-        case "Attribute":
-        case "Skill":
-        case "CloseCombatTechnique":
-        case "RangedCombatTechnique":
-            return false;
-        default:
-            return assertExhaustive(ratedId);
-    }
-};
-const isPrerequisiteFor = (type, prerequisite, getById, traversedIds) => {
-    switch (prerequisite.tag) {
-        case "Activatable": {
-            if (prerequisite.activatable.id.tag === "Advantage" &&
-                prerequisite.activatable.id.advantage === getAdvantageId(type) &&
-                prerequisite.activatable.active) {
-                return true;
-            }
-            const entry = getById(prerequisite.activatable.id);
-            return entry !== undefined && is(type, entry, getById, traversedIds);
-        }
-        case "Rated":
-            return isRatedFor(type, prerequisite.rated.id);
-        case "CommonSuggestedByRCP":
-        case "Sex":
-        case "Race":
-        case "Culture":
-        case "Pact":
-        case "SocialStatus":
-        case "State":
-        case "Rule":
-        case "PrimaryAttribute":
-        case "BlessedTradition":
-        case "MagicalTradition":
-        case "RatedMinimumNumber":
-        case "RatedSum":
-        case "ExternalEnhancement":
-        case "Text":
-        case "NoOtherAncestorBloodAdvantage":
-        case "SexualCharacteristic":
-            return false;
-        default:
-            return assertExhaustive(prerequisite);
-    }
-};
-const is = (type, entry, getById, traversedIds) => {
-    if (!entry.prerequisites || traversedIds.includes(entry.id)) {
-        return false;
-    }
-    const newTraversedIds = [...traversedIds, entry.id];
-    return (entry.prerequisites !== undefined &&
-        entry.prerequisites.some(prerequisite => {
-            switch (prerequisite.prerequisite.tag) {
-                case "Single":
-                    return isPrerequisiteFor(type, prerequisite.prerequisite.single, getById, newTraversedIds);
-                case "Disjunction":
-                    return prerequisite.prerequisite.disjunction.list.some(p => isPrerequisiteFor(type, p, getById, newTraversedIds));
-                case "Group":
-                    return prerequisite.prerequisite.group.list.some(p => isPrerequisiteFor(type, p, getById, newTraversedIds));
-                default:
-                    return assertExhaustive(prerequisite.prerequisite);
-            }
-        }));
-};
-export const config = {
-    builder(database) {
-        const getActivatableById = (id) => {
-            // prettier-ignore
-            switch (id.tag) {
-                case "AdvancedCombatSpecialAbility": return database.advancedCombatSpecialAbilities.find(([entryId]) => entryId === id.advanced_combat_special_ability)?.[1];
-                case "AdvancedKarmaSpecialAbility": return database.advancedKarmaSpecialAbilities.find(([entryId]) => entryId === id.advanced_karma_special_ability)?.[1];
-                case "AdvancedMagicalSpecialAbility": return database.advancedMagicalSpecialAbilities.find(([entryId]) => entryId === id.advanced_magical_special_ability)?.[1];
-                case "AdvancedSkillSpecialAbility": return database.advancedSkillSpecialAbilities.find(([entryId]) => entryId === id.advanced_skill_special_ability)?.[1];
-                case "Advantage": return database.advantages.find(([entryId]) => entryId === id.advantage)?.[1];
-                case "AncestorGlyph": return database.ancestorGlyphs.find(([entryId]) => entryId === id.ancestor_glyph)?.[1];
-                case "ArcaneOrbEnchantment": return database.arcaneOrbEnchantments.find(([entryId]) => entryId === id.arcane_orb_enchantment)?.[1];
-                case "AttireEnchantment": return database.attireEnchantments.find(([entryId]) => entryId === id.attire_enchantment)?.[1];
-                case "BlessedTradition": return database.blessedTraditions.find(([entryId]) => entryId === id.blessed_tradition)?.[1];
-                case "BowlEnchantment": return database.bowlEnchantments.find(([entryId]) => entryId === id.bowl_enchantment)?.[1];
-                case "BrawlingSpecialAbility": return database.brawlingSpecialAbilities.find(([entryId]) => entryId === id.brawling_special_ability)?.[1];
-                case "CauldronEnchantment": return database.cauldronEnchantments.find(([entryId]) => entryId === id.cauldron_enchantment)?.[1];
-                case "CeremonialItemSpecialAbility": return database.ceremonialItemSpecialAbilities.find(([entryId]) => entryId === id.ceremonial_item_special_ability)?.[1];
-                case "ChronicleEnchantment": return database.chronicleEnchantments.find(([entryId]) => entryId === id.chronicle_enchantment)?.[1];
-                case "CombatSpecialAbility": return database.combatSpecialAbilities.find(([entryId]) => entryId === id.combat_special_ability)?.[1];
-                case "CombatStyleSpecialAbility": return database.combatStyleSpecialAbilities.find(([entryId]) => entryId === id.combat_style_special_ability)?.[1];
-                case "CommandSpecialAbility": return database.commandSpecialAbilities.find(([entryId]) => entryId === id.command_special_ability)?.[1];
-                case "DaggerRitual": return database.daggerRituals.find(([entryId]) => entryId === id.dagger_ritual)?.[1];
-                case "Disadvantage": return database.disadvantages.find(([entryId]) => entryId === id.disadvantage)?.[1];
-                case "FamiliarSpecialAbility": return database.familiarSpecialAbilities.find(([entryId]) => entryId === id.familiar_special_ability)?.[1];
-                case "FatePointSexSpecialAbility": return database.fatePointSexSpecialAbilities.find(([entryId]) => entryId === id.fate_point_sex_special_ability)?.[1];
-                case "FatePointSpecialAbility": return database.fatePointSpecialAbilities.find(([entryId]) => entryId === id.fate_point_special_ability)?.[1];
-                case "FoolsHatEnchantment": return database.foolsHatEnchantments.find(([entryId]) => entryId === id.fools_hat_enchantment)?.[1];
-                case "GeneralSpecialAbility": return database.generalSpecialAbilities.find(([entryId]) => entryId === id.general_special_ability)?.[1];
-                case "InstrumentEnchantment": return database.instrumentEnchantments.find(([entryId]) => entryId === id.instrument_enchantment)?.[1];
-                case "KarmaSpecialAbility": return database.karmaSpecialAbilities.find(([entryId]) => entryId === id.karma_special_ability)?.[1];
-                case "Krallenkettenzauber": return database.krallenkettenzauber.find(([entryId]) => entryId === id.krallenkettenzauber)?.[1];
-                case "LiturgicalStyleSpecialAbility": return database.liturgicalStyleSpecialAbilities.find(([entryId]) => entryId === id.liturgical_style_special_ability)?.[1];
-                case "LycantropicGift": return database.lycantropicGifts.find(([entryId]) => entryId === id.lycantropic_gift)?.[1];
-                case "MagicalSign": return database.magicalSigns.find(([entryId]) => entryId === id.magical_sign)?.[1];
-                case "MagicalSpecialAbility": return database.magicalSpecialAbilities.find(([entryId]) => entryId === id.magical_special_ability)?.[1];
-                case "MagicalTradition": return database.magicalTraditions.find(([entryId]) => entryId === id.magical_tradition)?.[1];
-                case "MagicStyleSpecialAbility": return database.magicStyleSpecialAbilities.find(([entryId]) => entryId === id.magic_style_special_ability)?.[1];
-                case "OrbEnchantment": return database.orbEnchantments.find(([entryId]) => entryId === id.orb_enchantment)?.[1];
-                case "PactGift": return database.pactGifts.find(([entryId]) => entryId === id.pact_gift)?.[1];
-                case "ProtectiveWardingCircleSpecialAbility": return database.protectiveWardingCircleSpecialAbilities.find(([entryId]) => entryId === id.protective_warding_circle_special_ability)?.[1];
-                case "RingEnchantment": return database.ringEnchantments.find(([entryId]) => entryId === id.ring_enchantment)?.[1];
-                case "Sermon": return database.sermons.find(([entryId]) => entryId === id.sermon)?.[1];
-                case "SexSpecialAbility": return database.sexSpecialAbilities.find(([entryId]) => entryId === id.sex_special_ability)?.[1];
-                case "SickleRitual": return database.sickleRituals.find(([entryId]) => entryId === id.sickle_ritual)?.[1];
-                case "SikaryanDrainSpecialAbility": return database.sikaryanDrainSpecialAbilities.find(([entryId]) => entryId === id.sikaryan_drain_special_ability)?.[1];
-                case "SkillStyleSpecialAbility": return database.skillStyleSpecialAbilities.find(([entryId]) => entryId === id.skill_style_special_ability)?.[1];
-                case "SpellSwordEnchantment": return database.spellSwordEnchantments.find(([entryId]) => entryId === id.spell_sword_enchantment)?.[1];
-                case "StaffEnchantment": return database.staffEnchantments.find(([entryId]) => entryId === id.staff_enchantment)?.[1];
-                case "ToyEnchantment": return database.toyEnchantments.find(([entryId]) => entryId === id.toy_enchantment)?.[1];
-                case "Trinkhornzauber": return database.trinkhornzauber.find(([entryId]) => entryId === id.trinkhornzauber)?.[1];
-                case "VampiricGift": return database.vampiricGifts.find(([entryId]) => entryId === id.vampiric_gift)?.[1];
-                case "Vision": return database.visions.find(([entryId]) => entryId === id.vision)?.[1];
-                case "WandEnchantment": return database.wandEnchantments.find(([entryId]) => entryId === id.wand_enchantment)?.[1];
-                case "WeaponEnchantment": return database.weaponEnchantments.find(([entryId]) => entryId === id.weapon_enchantment)?.[1];
-                default:
-                    return assertExhaustive(id);
-            }
-        };
-        // prettier-ignore
-        return {
-            advantages: {
-                magical: {
-                    ids: database.advantages.filter(([_, entry]) => is("Magical", entry, getActivatableById, [])).map(([id]) => id),
-                },
-                blessed: {
-                    ids: database.advantages.filter(([_, entry]) => is("Blessed", entry, getActivatableById, [])).map(([id]) => id),
-                },
-            },
-            disadvantages: {
-                magical: {
-                    ids: database.disadvantages.filter(([_, entry]) => is("Magical", entry, getActivatableById, [])).map(([id]) => id),
-                },
-                blessed: {
-                    ids: database.disadvantages.filter(([_, entry]) => is("Blessed", entry, getActivatableById, [])).map(([id]) => id),
-                },
-            },
-        };
-    },
-};

package/lib/cache/newApplicationsAndUses.d.ts

@@ -1,20 +0,0 @@
-import type { CacheConfig } from "../cacheConfig.js";
-import type { SkillApplication, SkillUse } from "../types/_Activatable.js";
-import type { ActivatableIdentifier } from "../types/_IdentifierGroup.js";
-import { ActivatableSelectOptionsCache } from "./activatableSelectOptions.js";
-export type NewApplication = {
-    source: ActivatableIdentifier;
-    data: SkillApplication;
-    requiredSkillRating?: number;
-};
-export type Use = {
-    source: ActivatableIdentifier;
-    data: SkillUse;
-};
-export type NewApplicationsAndUsesCache = {
-    newApplications: Record<number, NewApplication[]>;
-    uses: Record<number, Use[]>;
-};
-export declare const config: CacheConfig<NewApplicationsAndUsesCache, [
-    generatedSelectOptions: ActivatableSelectOptionsCache
-]>;

package/lib/cache/newApplicationsAndUses.js

@@ -1,126 +0,0 @@
-export const config = {
-    builder(database, generatedSelectOptions) {
-        const cache = {
-            newApplications: {},
-            uses: {},
-        };
-        const addNewApplicationsAndUses = (activatable, activatableId) => {
-            if (activatable.skill_applications) {
-                for (const newApplication of activatable.skill_applications) {
-                    const pair = { source: activatableId, data: newApplication };
-                    if (newApplication.skill.tag === "Single") {
-                        const previous = (cache.newApplications[newApplication.skill.single.id.skill] ??= []);
-                        previous.push(pair);
-                    }
-                    else {
-                        for (const skill of newApplication.skill.multiple.list) {
-                            const previous = (cache.newApplications[skill.id.skill] ??= []);
-                            previous.push(pair);
-                        }
-                        if (newApplication.skill.multiple.required_skill_rating !== undefined) {
-                            pair.requiredSkillRating = newApplication.skill.multiple.required_skill_rating;
-                        }
-                    }
-                }
-            }
-            if (activatable.skill_uses) {
-                for (const use of activatable.skill_uses) {
-                    const pair = { source: activatableId, data: use };
-                    if (use.skill.tag === "Single") {
-                        const previous = (cache.uses[use.skill.single.id.skill] ??= []);
-                        previous.push(pair);
-                    }
-                    else {
-                        for (const skill of use.skill.multiple.list) {
-                            const previous = (cache.uses[skill.id.skill] ??= []);
-                            previous.push(pair);
-                        }
-                    }
-                }
-            }
-        };
-        // prettier-ignore
-        const entries = [
-            [database.advancedCombatSpecialAbilities, n => ({ tag: "AdvancedCombatSpecialAbility", advanced_combat_special_ability: n })],
-            [database.advancedKarmaSpecialAbilities, n => ({ tag: "AdvancedKarmaSpecialAbility", advanced_karma_special_ability: n })],
-            [database.advancedMagicalSpecialAbilities, n => ({ tag: "AdvancedMagicalSpecialAbility", advanced_magical_special_ability: n })],
-            [database.advancedSkillSpecialAbilities, n => ({ tag: "AdvancedSkillSpecialAbility", advanced_skill_special_ability: n })],
-            [database.advantages, n => ({ tag: "Advantage", advantage: n })],
-            [database.blessedTraditions, n => ({ tag: "BlessedTradition", blessed_tradition: n })],
-            [database.ceremonialItemSpecialAbilities, n => ({ tag: "CeremonialItemSpecialAbility", ceremonial_item_special_ability: n })],
-            [database.combatSpecialAbilities, n => ({ tag: "CombatSpecialAbility", combat_special_ability: n })],
-            [database.combatStyleSpecialAbilities, n => ({ tag: "CombatStyleSpecialAbility", combat_style_special_ability: n })],
-            [database.fatePointSpecialAbilities, n => ({ tag: "FatePointSpecialAbility", fate_point_special_ability: n })],
-            [database.generalSpecialAbilities, n => ({ tag: "GeneralSpecialAbility", general_special_ability: n })],
-            [database.liturgicalStyleSpecialAbilities, n => ({ tag: "LiturgicalStyleSpecialAbility", liturgical_style_special_ability: n })],
-            [database.magicStyleSpecialAbilities, n => ({ tag: "MagicStyleSpecialAbility", magic_style_special_ability: n })],
-            [database.magicalSpecialAbilities, n => ({ tag: "MagicalSpecialAbility", magical_special_ability: n })],
-            [database.magicalTraditions, n => ({ tag: "MagicalTradition", magical_tradition: n })],
-            [database.sexSpecialAbilities, n => ({ tag: "SexSpecialAbility", sex_special_ability: n })],
-        ];
-        entries.forEach(([entityEntries, createId]) => {
-            entityEntries.forEach(([numericId, activatable]) => {
-                addNewApplicationsAndUses(activatable, createId(numericId));
-            });
-        });
-        // prettier-ignore
-        const generatedEntries = [
-            [generatedSelectOptions.advancedCombatSpecialAbilities, id => ({ tag: "AdvancedCombatSpecialAbility", advanced_combat_special_ability: id })],
-            [generatedSelectOptions.advancedKarmaSpecialAbilities, id => ({ tag: "AdvancedKarmaSpecialAbility", advanced_karma_special_ability: id })],
-            [generatedSelectOptions.advancedMagicalSpecialAbilities, id => ({ tag: "AdvancedMagicalSpecialAbility", advanced_magical_special_ability: id })],
-            [generatedSelectOptions.advancedSkillSpecialAbilities, id => ({ tag: "AdvancedSkillSpecialAbility", advanced_skill_special_ability: id })],
-            [generatedSelectOptions.advantages, id => ({ tag: "Advantage", advantage: id })],
-            [generatedSelectOptions.ancestorGlyphs, id => ({ tag: "AncestorGlyph", ancestor_glyph: id })],
-            [generatedSelectOptions.arcaneOrbEnchantments, id => ({ tag: "ArcaneOrbEnchantment", arcane_orb_enchantment: id })],
-            [generatedSelectOptions.attireEnchantments, id => ({ tag: "AttireEnchantment", attire_enchantment: id })],
-            [generatedSelectOptions.blessedTraditions, id => ({ tag: "BlessedTradition", blessed_tradition: id })],
-            [generatedSelectOptions.bowlEnchantments, id => ({ tag: "BowlEnchantment", bowl_enchantment: id })],
-            [generatedSelectOptions.brawlingSpecialAbilities, id => ({ tag: "BrawlingSpecialAbility", brawling_special_ability: id })],
-            [generatedSelectOptions.cauldronEnchantments, id => ({ tag: "CauldronEnchantment", cauldron_enchantment: id })],
-            [generatedSelectOptions.ceremonialItemSpecialAbilities, id => ({ tag: "CeremonialItemSpecialAbility", ceremonial_item_special_ability: id })],
-            [generatedSelectOptions.chronicleEnchantments, id => ({ tag: "ChronicleEnchantment", chronicle_enchantment: id })],
-            [generatedSelectOptions.combatSpecialAbilities, id => ({ tag: "CombatSpecialAbility", combat_special_ability: id })],
-            [generatedSelectOptions.combatStyleSpecialAbilities, id => ({ tag: "CombatStyleSpecialAbility", combat_style_special_ability: id })],
-            [generatedSelectOptions.commandSpecialAbilities, id => ({ tag: "CommandSpecialAbility", command_special_ability: id })],
-            [generatedSelectOptions.daggerRituals, id => ({ tag: "DaggerRitual", dagger_ritual: id })],
-            [generatedSelectOptions.disadvantages, id => ({ tag: "Disadvantage", disadvantage: id })],
-            [generatedSelectOptions.familiarSpecialAbilities, id => ({ tag: "FamiliarSpecialAbility", familiar_special_ability: id })],
-            [generatedSelectOptions.fatePointSexSpecialAbilities, id => ({ tag: "FatePointSexSpecialAbility", fate_point_sex_special_ability: id })],
-            [generatedSelectOptions.fatePointSpecialAbilities, id => ({ tag: "FatePointSpecialAbility", fate_point_special_ability: id })],
-            [generatedSelectOptions.foolsHatEnchantments, id => ({ tag: "FoolsHatEnchantment", fools_hat_enchantment: id })],
-            [generatedSelectOptions.generalSpecialAbilities, id => ({ tag: "GeneralSpecialAbility", general_special_ability: id })],
-            [generatedSelectOptions.instrumentEnchantments, id => ({ tag: "InstrumentEnchantment", instrument_enchantment: id })],
-            [generatedSelectOptions.karmaSpecialAbilities, id => ({ tag: "KarmaSpecialAbility", karma_special_ability: id })],
-            [generatedSelectOptions.krallenkettenzauber, id => ({ tag: "Krallenkettenzauber", krallenkettenzauber: id })],
-            [generatedSelectOptions.liturgicalStyleSpecialAbilities, id => ({ tag: "LiturgicalStyleSpecialAbility", liturgical_style_special_ability: id })],
-            [generatedSelectOptions.lycantropicGifts, id => ({ tag: "LycantropicGift", lycantropic_gift: id })],
-            [generatedSelectOptions.magicalSpecialAbilities, id => ({ tag: "MagicalSpecialAbility", magical_special_ability: id })],
-            [generatedSelectOptions.magicalTraditions, id => ({ tag: "MagicalTradition", magical_tradition: id })],
-            [generatedSelectOptions.magicStyleSpecialAbilities, id => ({ tag: "MagicStyleSpecialAbility", magic_style_special_ability: id })],
-            [generatedSelectOptions.orbEnchantments, id => ({ tag: "OrbEnchantment", orb_enchantment: id })],
-            [generatedSelectOptions.pactGifts, id => ({ tag: "PactGift", pact_gift: id })],
-            [generatedSelectOptions.protectiveWardingCircleSpecialAbilities, id => ({ tag: "ProtectiveWardingCircleSpecialAbility", protective_warding_circle_special_ability: id })],
-            [generatedSelectOptions.ringEnchantments, id => ({ tag: "RingEnchantment", ring_enchantment: id })],
-            [generatedSelectOptions.sermons, id => ({ tag: "Sermon", sermon: id })],
-            [generatedSelectOptions.sexSpecialAbilities, id => ({ tag: "SexSpecialAbility", sex_special_ability: id })],
-            [generatedSelectOptions.sickleRituals, id => ({ tag: "SickleRitual", sickle_ritual: id })],
-            [generatedSelectOptions.sikaryanDrainSpecialAbilities, id => ({ tag: "SikaryanDrainSpecialAbility", sikaryan_drain_special_ability: id })],
-            [generatedSelectOptions.staffEnchantments, id => ({ tag: "StaffEnchantment", staff_enchantment: id })],
-            [generatedSelectOptions.skillStyleSpecialAbilities, id => ({ tag: "SkillStyleSpecialAbility", skill_style_special_ability: id })],
-            [generatedSelectOptions.spellSwordEnchantments, id => ({ tag: "SpellSwordEnchantment", spell_sword_enchantment: id })],
-            [generatedSelectOptions.toyEnchantments, id => ({ tag: "ToyEnchantment", toy_enchantment: id })],
-            [generatedSelectOptions.trinkhornzauber, id => ({ tag: "Trinkhornzauber", trinkhornzauber: id })],
-            [generatedSelectOptions.vampiricGifts, id => ({ tag: "VampiricGift", vampiric_gift: id })],
-            [generatedSelectOptions.visions, id => ({ tag: "Vision", vision: id })],
-            [generatedSelectOptions.wandEnchantments, id => ({ tag: "WandEnchantment", wand_enchantment: id })],
-            [generatedSelectOptions.weaponEnchantments, id => ({ tag: "WeaponEnchantment", weapon_enchantment: id })],
-        ];
-        generatedEntries.forEach(([ids, createId]) => Object.entries(ids).forEach(([stringId, selectOptions]) => {
-            const id = createId(Number.parseInt(stringId));
-            selectOptions.forEach(selectOption => {
-                addNewApplicationsAndUses(selectOption, id);
-            });
-        }));
-        return cache;
-    },
-};

package/lib/cacheConfig.d.ts

@@ -1,4 +0,0 @@
-import { ValidResults } from "./main.js";
-export type CacheConfig<T, D extends unknown[] = []> = {
-    builder: (data: ValidResults, ...deps: D) => T;
-};

package/lib/cacheConfig.js

@@ -1 +0,0 @@
-export {};

package/lib/config/build.d.ts

@@ -1,6 +0,0 @@
-import { JsonSchemaSpec } from "optolith-tsjsonschemamd/renderers/jsonSchema";
-export declare const sourceDir: string;
-export declare const libDir: string;
-export declare const jsonSchemaDir: string;
-export declare const markdownDir: string;
-export declare const jsonSchemaSpec: JsonSchemaSpec;

package/lib/config/build.js

@@ -1,8 +0,0 @@
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-const root = join(dirname(fileURLToPath(import.meta.url)), "..", "..");
-export const sourceDir = join(root, "src", "types");
-export const libDir = join(root, "lib", "types");
-export const jsonSchemaDir = join(root, "schema");
-export const markdownDir = join(root, "docs", "reference");
-export const jsonSchemaSpec = "Draft_2019_09";

package/lib/config/cache.d.ts

@@ -1,16 +0,0 @@
-import * as ActivatableSelectOptions from "../cache/activatableSelectOptions.js";
-import * as AncestorBloodAdvantages from "../cache/ancestorBloodAdvantages.js";
-import * as MagicalAndBlessedAdvantagesAndDisadvantages from "../cache/magicalAndBlessedAdvantagesAndDisadvantages.js";
-import * as NewApplicationsAndUses from "../cache/newApplicationsAndUses.js";
-export type CacheMap = {
-    activatableSelectOptions: ActivatableSelectOptions.ActivatableSelectOptionsCache;
-    ancestorBloodAdvantages: AncestorBloodAdvantages.AncestorBloodAdvantagesCache;
-    magicalAndBlessedAdvantagesAndDisadvantages: MagicalAndBlessedAdvantagesAndDisadvantages.MagicalAndBlessedAdvantagesAndDisadvantagesCache;
-    newApplicationsAndUses: NewApplicationsAndUses.NewApplicationsAndUsesCache;
-};
-export declare const cacheMap: {
-    activatableSelectOptions: import("../cacheConfig.js").CacheConfig<ActivatableSelectOptions.ActivatableSelectOptionsCache>;
-    ancestorBloodAdvantages: import("../cacheConfig.js").CacheConfig<AncestorBloodAdvantages.AncestorBloodAdvantagesCache>;
-    magicalAndBlessedAdvantagesAndDisadvantages: import("../cacheConfig.js").CacheConfig<MagicalAndBlessedAdvantagesAndDisadvantages.MagicalAndBlessedAdvantagesAndDisadvantagesCache>;
-    newApplicationsAndUses: import("../cacheConfig.js").CacheConfig<NewApplicationsAndUses.NewApplicationsAndUsesCache, [generatedSelectOptions: ActivatableSelectOptions.ActivatableSelectOptionsCache]>;
-};

package/lib/config/cache.js

@@ -1,10 +0,0 @@
-import * as ActivatableSelectOptions from "../cache/activatableSelectOptions.js";
-import * as AncestorBloodAdvantages from "../cache/ancestorBloodAdvantages.js";
-import * as MagicalAndBlessedAdvantagesAndDisadvantages from "../cache/magicalAndBlessedAdvantagesAndDisadvantages.js";
-import * as NewApplicationsAndUses from "../cache/newApplicationsAndUses.js";
-export const cacheMap = {
-    activatableSelectOptions: ActivatableSelectOptions.config,
-    ancestorBloodAdvantages: AncestorBloodAdvantages.config,
-    magicalAndBlessedAdvantagesAndDisadvantages: MagicalAndBlessedAdvantagesAndDisadvantages.config,
-    newApplicationsAndUses: NewApplicationsAndUses.config,
-};