optolith-database-schema 0.1.4 → 0.1.7

package/CHANGELOG.md

@@ -2,6 +2,38 @@
 
 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
 
+### [0.1.7](https://github.com/elyukai/optolith-database-schema/compare/v0.1.6...v0.1.7) (2022-03-16)
+
+
+### Features
+
+* add basic validation utilities ([5676d39](https://github.com/elyukai/optolith-database-schema/commit/5676d39a3285901b750314832d7978692b1d26de))
+* add validation by schema for all types ([b3578ef](https://github.com/elyukai/optolith-database-schema/commit/b3578ef7914db35dbdfda87e1ccf95d37f61e9d7))
+* read magical actions ([543ef8e](https://github.com/elyukai/optolith-database-schema/commit/543ef8ee3567d4ec946f1be2492056d74de54976))
+
+
+### Bug Fixes
+
+* add extension to all relative module specifiers ([1a0b029](https://github.com/elyukai/optolith-database-schema/commit/1a0b029de43ce2026d9134b0f6dd3ee1f106afa2))
+* relative links to top-level schema documents ([065efab](https://github.com/elyukai/optolith-database-schema/commit/065efab03a5b4547a9bdc2c1fcf4a3ad010d858e))
+
+### [0.1.6](https://github.com/elyukai/optolith-database-schema/compare/v0.1.5...v0.1.6) (2022-03-11)
+
+### [0.1.5](https://github.com/elyukai/optolith-database-schema/compare/v0.1.4...v0.1.5) (2022-03-10)
+
+
+### Features
+
+* prerequisites ([148ffd4](https://github.com/elyukai/optolith-database-schema/commit/148ffd47a70b9fb3a1bad540de8b89319a4f8c7d))
+* select options for activatable entries ([9af975b](https://github.com/elyukai/optolith-database-schema/commit/9af975bcd1425f2a252ea41930233c3531376615))
+
+
+### Bug Fixes
+
+* exported name of select options ([5ecef02](https://github.com/elyukai/optolith-database-schema/commit/5ecef02d0178c7252f3b4a11d5ca0373908d6b87))
+* keep deprecated penalty translation strings ([e4a8d91](https://github.com/elyukai/optolith-database-schema/commit/e4a8d910dd561255d21801616b2c44fcdd28a30f))
+* keep deprecated translation strings for tradition artifact enchantments ([351146e](https://github.com/elyukai/optolith-database-schema/commit/351146ef87691d645a74d8f538d060095b8f7ac5))
+
 ### [0.1.4](https://github.com/elyukai/optolith-database-schema/compare/v0.1.3...v0.1.4) (2022-03-09)
 
 

package/lib/config.d.ts

@@ -0,0 +1,228 @@
+import { Advantage } from "./types/Advantage.js";
+import { ArcaneBardTradition } from "./types/ArcaneBardTradition.js";
+import { ArcaneDancerTradition } from "./types/ArcaneDancerTradition.js";
+import { Aspect } from "./types/Aspect.js";
+import { Attribute } from "./types/Attribute.js";
+import { Blessing } from "./types/Blessing.js";
+import { Cantrip } from "./types/Cantrip.js";
+import { Ceremony } from "./types/Ceremony.js";
+import { CloseCombatTechnique } from "./types/CombatTechnique_Close.js";
+import { RangedCombatTechnique } from "./types/CombatTechnique_Ranged.js";
+import { Condition } from "./types/Condition.js";
+import { Continent } from "./types/Continent.js";
+import { Culture } from "./types/Culture.js";
+import { DerivedCharacteristic } from "./types/DerivedCharacteristic.js";
+import { Disadvantage } from "./types/Disadvantage.js";
+import { Element } from "./types/Element.js";
+import { ExperienceLevel } from "./types/ExperienceLevel.js";
+import { EyeColor } from "./types/EyeColor.js";
+import { FamiliarsTrick } from "./types/FamiliarsTrick.js";
+import { AnimalType } from "./types/FamiliarsTrick_AnimalType.js";
+import { HairColor } from "./types/HairColor.js";
+import { Curriculum } from "./types/Lessons_Curriculum.js";
+import { Guideline } from "./types/Lessons_Guideline.js";
+import { LiturgicalChant } from "./types/LiturgicalChant.js";
+import { Locales } from "./types/Locale.js";
+import { AnimistPower } from "./types/magicalActions/AnimistPower.js";
+import { Tribe } from "./types/magicalActions/AnimistPower_Tribe.js";
+import { Curse } from "./types/magicalActions/Curse.js";
+import { DominationRitual } from "./types/magicalActions/DominationRitual.js";
+import { ElvenMagicalSong } from "./types/magicalActions/ElvenMagicalSong.js";
+import { GeodeRitual } from "./types/magicalActions/GeodeRitual.js";
+import { JesterTrick } from "./types/magicalActions/JesterTrick.js";
+import { MagicalDance } from "./types/magicalActions/MagicalDance.js";
+import { MagicalMelody } from "./types/magicalActions/MagicalMelody.js";
+import { MagicalRune } from "./types/magicalActions/MagicalRune.js";
+import { ZibiljaRitual } from "./types/magicalActions/ZibiljaRitual.js";
+import { MetaCondition } from "./types/MetaCondition.js";
+import { PactCategory } from "./types/PactCategory.js";
+import { Patron } from "./types/Patron.js";
+import { PatronCategory } from "./types/PatronCategory.js";
+import { Property } from "./types/Property.js";
+import { Race } from "./types/Race.js";
+import { Region } from "./types/Region.js";
+import { Ritual } from "./types/Ritual.js";
+import { FocusRule } from "./types/rule/FocusRule.js";
+import { Subject } from "./types/rule/FocusRule_Subject.js";
+import { OptionalRule } from "./types/rule/OptionalRule.js";
+import { Service } from "./types/Service.js";
+import { SexPractice } from "./types/SexPractice.js";
+import { Skill } from "./types/Skill.js";
+import { SkillGroup } from "./types/SkillGroup.js";
+import { SkillModificationLevel } from "./types/SkillModificationLevel.js";
+import { SocialStatus } from "./types/SocialStatus.js";
+import { Publication } from "./types/source/Publication.js";
+import { AdvancedCombatSpecialAbility } from "./types/specialAbility/AdvancedCombatSpecialAbility.js";
+import { AdvancedKarmaSpecialAbility } from "./types/specialAbility/AdvancedKarmaSpecialAbility.js";
+import { AdvancedMagicalSpecialAbility } from "./types/specialAbility/AdvancedMagicalSpecialAbility.js";
+import { AdvancedSkillSpecialAbility } from "./types/specialAbility/AdvancedSkillSpecialAbility.js";
+import { AncestorGlyph } from "./types/specialAbility/AncestorGlyph.js";
+import { BlessedTradition } from "./types/specialAbility/BlessedTradition.js";
+import { BrawlingSpecialAbility } from "./types/specialAbility/BrawlingSpecialAbility.js";
+import { CeremonialItemSpecialAbility } from "./types/specialAbility/CeremonialItemSpecialAbility.js";
+import { CombatSpecialAbility } from "./types/specialAbility/CombatSpecialAbility.js";
+import { CombatStyleSpecialAbility } from "./types/specialAbility/CombatStyleSpecialAbility.js";
+import { CommandSpecialAbility } from "./types/specialAbility/CommandSpecialAbility.js";
+import { FamiliarSpecialAbility } from "./types/specialAbility/FamiliarSpecialAbility.js";
+import { FatePointSexSpecialAbility } from "./types/specialAbility/FatePointSexSpecialAbility.js";
+import { FatePointSpecialAbility } from "./types/specialAbility/FatePointSpecialAbility.js";
+import { GeneralSpecialAbility } from "./types/specialAbility/GeneralSpecialAbility.js";
+import { KarmaSpecialAbility } from "./types/specialAbility/KarmaSpecialAbility.js";
+import { LiturgicalStyleSpecialAbility } from "./types/specialAbility/LiturgicalStyleSpecialAbility.js";
+import { LycantropicGift } from "./types/specialAbility/LycantropicGift.js";
+import { MagicalSpecialAbility } from "./types/specialAbility/MagicalSpecialAbility.js";
+import { MagicalTradition } from "./types/specialAbility/MagicalTradition.js";
+import { MagicStyleSpecialAbility } from "./types/specialAbility/MagicStyleSpecialAbility.js";
+import { PactGift } from "./types/specialAbility/PactGift.js";
+import { ProtectiveWardingCircleSpecialAbility } from "./types/specialAbility/ProtectiveWardingCircleSpecialAbility.js";
+import { Sermon } from "./types/specialAbility/Sermon.js";
+import { SexSpecialAbility } from "./types/specialAbility/SexSpecialAbility.js";
+import { SikaryanDrainSpecialAbility } from "./types/specialAbility/SikaryanDrainSpecialAbility.js";
+import { SkillStyleSpecialAbility } from "./types/specialAbility/SkillStyleSpecialAbility.js";
+import { Language } from "./types/specialAbility/sub/Language.js";
+import { Script } from "./types/specialAbility/sub/Script.js";
+import { TradeSecret } from "./types/specialAbility/sub/TradeSecret.js";
+import { VampiricGift } from "./types/specialAbility/VampiricGift.js";
+import { Vision } from "./types/specialAbility/Vision.js";
+import { Spell } from "./types/Spell.js";
+import { State } from "./types/State.js";
+import { TargetCategory } from "./types/TargetCategory.js";
+import { ArcaneOrbEnchantment } from "./types/traditionArtifacts/ArcaneOrbEnchantment.js";
+import { AttireEnchantment } from "./types/traditionArtifacts/AttireEnchantment.js";
+import { BowlEnchantment } from "./types/traditionArtifacts/BowlEnchantment.js";
+import { CauldronEnchantment } from "./types/traditionArtifacts/CauldronEnchantment.js";
+import { ChronicleEnchantment } from "./types/traditionArtifacts/ChronicleEnchantment.js";
+import { DaggerRitual } from "./types/traditionArtifacts/DaggerRitual.js";
+import { FoolsHatEnchantment } from "./types/traditionArtifacts/FoolsHatEnchantment.js";
+import { InstrumentEnchantment } from "./types/traditionArtifacts/InstrumentEnchantment.js";
+import { Krallenkettenzauber } from "./types/traditionArtifacts/Krallenkettenzauber.js";
+import { OrbEnchantment } from "./types/traditionArtifacts/OrbEnchantment.js";
+import { RingEnchantment } from "./types/traditionArtifacts/RingEnchantment.js";
+import { SickleRitual } from "./types/traditionArtifacts/SickleRitual.js";
+import { SpellSwordEnchantment } from "./types/traditionArtifacts/SpellSwordEnchantment.js";
+import { StaffEnchantment } from "./types/traditionArtifacts/StaffEnchantment.js";
+import { AnimalShape } from "./types/traditionArtifacts/sub/AnimalShape.js";
+import { AnimalShapePath } from "./types/traditionArtifacts/sub/AnimalShapePath.js";
+import { AnimalShapeSize } from "./types/traditionArtifacts/sub/AnimalShapeSize.js";
+import { Brew } from "./types/traditionArtifacts/sub/Brew.js";
+import { ToyEnchantment } from "./types/traditionArtifacts/ToyEnchantment.js";
+import { Trinkhornzauber } from "./types/traditionArtifacts/Trinkhornzauber.js";
+import { WandEnchantment } from "./types/traditionArtifacts/WandEnchantment.js";
+import { WeaponEnchantment } from "./types/traditionArtifacts/WeaponEnchantment.js";
+import { TypeValidator } from "./validation/schema.js";
+export declare type TypeMap = {
+    advancedCombatSpecialAbilities: AdvancedCombatSpecialAbility;
+    advancedKarmaSpecialAbilities: AdvancedKarmaSpecialAbility;
+    advancedMagicalSpecialAbilities: AdvancedMagicalSpecialAbility;
+    advancedSkillSpecialAbilities: AdvancedSkillSpecialAbility;
+    advantages: Advantage;
+    ancestorGlyphs: AncestorGlyph;
+    animalShapePaths: AnimalShapePath;
+    animalShapes: AnimalShape;
+    animalShapeSizes: AnimalShapeSize;
+    animistPowers: AnimistPower;
+    animistPowerTribes: Tribe;
+    arcaneBardTraditions: ArcaneBardTradition;
+    arcaneDancerTraditions: ArcaneDancerTradition;
+    arcaneOrbEnchantments: ArcaneOrbEnchantment;
+    aspects: Aspect;
+    attireEnchantments: AttireEnchantment;
+    attributes: Attribute;
+    blessedTraditions: BlessedTradition;
+    blessings: Blessing;
+    bowlEnchantments: BowlEnchantment;
+    brawlingSpecialAbilities: BrawlingSpecialAbility;
+    brews: Brew;
+    cantrips: Cantrip;
+    cauldronEnchantments: CauldronEnchantment;
+    ceremonialItemSpecialAbilities: CeremonialItemSpecialAbility;
+    ceremonies: Ceremony;
+    chronicleEnchantments: ChronicleEnchantment;
+    closeCombatTechniques: CloseCombatTechnique;
+    combatSpecialAbilities: CombatSpecialAbility;
+    combatStyleSpecialAbilities: CombatStyleSpecialAbility;
+    commandSpecialAbilities: CommandSpecialAbility;
+    conditions: Condition;
+    continents: Continent;
+    cultures: Culture;
+    curses: Curse;
+    daggerRituals: DaggerRitual;
+    derivedCharacteristics: DerivedCharacteristic;
+    disadvantages: Disadvantage;
+    dominationRituals: DominationRitual;
+    elements: Element;
+    elvenMagicalSongs: ElvenMagicalSong;
+    experienceLevels: ExperienceLevel;
+    eyeColors: EyeColor;
+    familiarSpecialAbilities: FamiliarSpecialAbility;
+    familiarsTrickAnimalTypes: AnimalType;
+    familiarsTricks: FamiliarsTrick;
+    fatePointSexSpecialAbilities: FatePointSexSpecialAbility;
+    fatePointSpecialAbilities: FatePointSpecialAbility;
+    focusRules: FocusRule;
+    focusRuleSubjects: Subject;
+    foolsHatEnchantments: FoolsHatEnchantment;
+    generalSpecialAbilities: GeneralSpecialAbility;
+    geodeRituals: GeodeRitual;
+    hairColors: HairColor;
+    instrumentEnchantments: InstrumentEnchantment;
+    jesterTricks: JesterTrick;
+    karmaSpecialAbilities: KarmaSpecialAbility;
+    krallenkettenzauber: Krallenkettenzauber;
+    languages: Language;
+    lessonsCurricula: Curriculum;
+    lessonsGuidelines: Guideline;
+    liturgicalChants: LiturgicalChant;
+    liturgicalStyleSpecialAbilities: LiturgicalStyleSpecialAbility;
+    locales: Locales;
+    lycantropicGifts: LycantropicGift;
+    magicalDances: MagicalDance;
+    magicalMelodies: MagicalMelody;
+    magicalRunes: MagicalRune;
+    magicalSpecialAbilities: MagicalSpecialAbility;
+    magicalTraditions: MagicalTradition;
+    magicStyleSpecialAbilities: MagicStyleSpecialAbility;
+    metaConditions: MetaCondition;
+    optionalRules: OptionalRule;
+    orbEnchantments: OrbEnchantment;
+    pactCategories: PactCategory;
+    pactGifts: PactGift;
+    patronCategories: PatronCategory;
+    patrons: Patron;
+    properties: Property;
+    protectiveWardingCircleSpecialAbilities: ProtectiveWardingCircleSpecialAbility;
+    publications: Publication;
+    races: Race;
+    rangedCombatTechniques: RangedCombatTechnique;
+    regions: Region;
+    ringEnchantments: RingEnchantment;
+    rituals: Ritual;
+    scripts: Script;
+    sermons: Sermon;
+    services: Service;
+    sexPractices: SexPractice;
+    sexSpecialAbilities: SexSpecialAbility;
+    sickleRituals: SickleRitual;
+    sikaryanDrainSpecialAbilities: SikaryanDrainSpecialAbility;
+    skillGroups: SkillGroup;
+    skillModificationLevels: SkillModificationLevel;
+    skills: Skill;
+    skillStyleSpecialAbilities: SkillStyleSpecialAbility;
+    socialStatuses: SocialStatus;
+    spells: Spell;
+    spellSwordEnchantments: SpellSwordEnchantment;
+    staffEnchantments: StaffEnchantment;
+    states: State;
+    targetCategories: TargetCategory;
+    toyEnchantments: ToyEnchantment;
+    tradeSecrets: TradeSecret;
+    trinkhornzauber: Trinkhornzauber;
+    vampiricGifts: VampiricGift;
+    visions: Vision;
+    wandEnchantments: WandEnchantment;
+    weaponEnchantments: WeaponEnchantment;
+    zibiljaRituals: ZibiljaRitual;
+};
+export declare const typeValidatorMap: {
+    [K in keyof TypeMap]: TypeValidator<TypeMap[K]>;
+};

package/lib/config.js

@@ -0,0 +1,224 @@
+import { validateSchema as validateAdvantageSchema } from "./types/Advantage.js";
+import { validateSchema as validateArcaneBardTraditionSchema } from "./types/ArcaneBardTradition.js";
+import { validateSchema as validateArcaneDancerTraditionSchema } from "./types/ArcaneDancerTradition.js";
+import { validateSchema as validateAspectSchema } from "./types/Aspect.js";
+import { validateSchema as validateAttributeSchema } from "./types/Attribute.js";
+import { validateSchema as validateBlessingSchema } from "./types/Blessing.js";
+import { validateSchema as validateCantripSchema } from "./types/Cantrip.js";
+import { validateSchema as validateCeremonySchema } from "./types/Ceremony.js";
+import { validateSchema as validateCloseCombatTechniqueSchema } from "./types/CombatTechnique_Close.js";
+import { validateSchema as validateRangedCombatTechniqueSchema } from "./types/CombatTechnique_Ranged.js";
+import { validateSchema as validateConditionSchema } from "./types/Condition.js";
+import { validateSchema as validateContinentSchema } from "./types/Continent.js";
+import { validateSchema as validateCultureSchema } from "./types/Culture.js";
+import { validateSchema as validateDerivedCharacteristicSchema } from "./types/DerivedCharacteristic.js";
+import { validateSchema as validateDisadvantageSchema } from "./types/Disadvantage.js";
+import { validateSchema as validateElementSchema } from "./types/Element.js";
+import { validateSchema as validateExperienceLevelSchema } from "./types/ExperienceLevel.js";
+import { validateSchema as validateEyeColorSchema } from "./types/EyeColor.js";
+import { validateSchema as validateFamiliarsTrickSchema } from "./types/FamiliarsTrick.js";
+import { validateSchema as validateAnimalTypeSchema } from "./types/FamiliarsTrick_AnimalType.js";
+import { validateSchema as validateHairColorSchema } from "./types/HairColor.js";
+import { validateSchema as validateCurriculumSchema } from "./types/Lessons_Curriculum.js";
+import { validateSchema as validateGuidelineSchema } from "./types/Lessons_Guideline.js";
+import { validateSchema as validateLiturgicalChantSchema } from "./types/LiturgicalChant.js";
+import { validateSchema as validateLocaleSchema } from "./types/Locale.js";
+import { validateSchema as validateAnimistPowerSchema } from "./types/magicalActions/AnimistPower.js";
+import { validateSchema as validateTribeSchema } from "./types/magicalActions/AnimistPower_Tribe.js";
+import { validateSchema as validateCurseSchema } from "./types/magicalActions/Curse.js";
+import { validateSchema as validateDominationRitualSchema } from "./types/magicalActions/DominationRitual.js";
+import { validateSchema as validateElvenMagicalSongSchema } from "./types/magicalActions/ElvenMagicalSong.js";
+import { validateSchema as validateGeodeRitualSchema } from "./types/magicalActions/GeodeRitual.js";
+import { validateSchema as validateJesterTrickSchema } from "./types/magicalActions/JesterTrick.js";
+import { validateSchema as validateMagicalDanceSchema } from "./types/magicalActions/MagicalDance.js";
+import { validateSchema as validateMagicalMelodySchema } from "./types/magicalActions/MagicalMelody.js";
+import { validateSchema as validateMagicalRuneSchema } from "./types/magicalActions/MagicalRune.js";
+import { validateSchema as validateZibiljaRitualSchema } from "./types/magicalActions/ZibiljaRitual.js";
+import { validateSchema as validateMetaConditionSchema } from "./types/MetaCondition.js";
+import { validateSchema as validatePactCategorySchema } from "./types/PactCategory.js";
+import { validateSchema as validatePatronSchema } from "./types/Patron.js";
+import { validateSchema as validatePatronCategorySchema } from "./types/PatronCategory.js";
+import { validateSchema as validatePropertySchema } from "./types/Property.js";
+import { validateSchema as validateRaceSchema } from "./types/Race.js";
+import { validateSchema as validateRegionSchema } from "./types/Region.js";
+import { validateSchema as validateRitualSchema } from "./types/Ritual.js";
+import { validateSchema as validateFocusRuleSchema } from "./types/rule/FocusRule.js";
+import { validateSchema as validateSubjectSchema } from "./types/rule/FocusRule_Subject.js";
+import { validateSchema as validateOptionalRuleSchema } from "./types/rule/OptionalRule.js";
+import { validateSchema as validateServiceSchema } from "./types/Service.js";
+import { validateSchema as validateSexPracticeSchema } from "./types/SexPractice.js";
+import { validateSchema as validateSkillSchema } from "./types/Skill.js";
+import { validateSchema as validateSkillGroupSchema } from "./types/SkillGroup.js";
+import { validateSchema as validateSkillModificationLevelSchema } from "./types/SkillModificationLevel.js";
+import { validateSchema as validateSocialStatusSchema } from "./types/SocialStatus.js";
+import { validateSchema as validatePublicationSchema } from "./types/source/Publication.js";
+import { validateSchema as validateAdvancedCombatSpecialAbilitySchema } from "./types/specialAbility/AdvancedCombatSpecialAbility.js";
+import { validateSchema as validateAdvancedKarmaSpecialAbilitySchema } from "./types/specialAbility/AdvancedKarmaSpecialAbility.js";
+import { validateSchema as validateAdvancedMagicalSpecialAbilitySchema } from "./types/specialAbility/AdvancedMagicalSpecialAbility.js";
+import { validateSchema as validateAdvancedSkillSpecialAbilitySchema } from "./types/specialAbility/AdvancedSkillSpecialAbility.js";
+import { validateSchema as validateAncestorGlyphSchema } from "./types/specialAbility/AncestorGlyph.js";
+import { validateSchema as validateBlessedTraditionSchema } from "./types/specialAbility/BlessedTradition.js";
+import { validateSchema as validateBrawlingSpecialAbilitySchema } from "./types/specialAbility/BrawlingSpecialAbility.js";
+import { validateSchema as validateCeremonialItemSpecialAbilitySchema } from "./types/specialAbility/CeremonialItemSpecialAbility.js";
+import { validateSchema as validateCombatSpecialAbilitySchema } from "./types/specialAbility/CombatSpecialAbility.js";
+import { validateSchema as validateCombatStyleSpecialAbilitySchema } from "./types/specialAbility/CombatStyleSpecialAbility.js";
+import { validateSchema as validateCommandSpecialAbilitySchema } from "./types/specialAbility/CommandSpecialAbility.js";
+import { validateSchema as validateFamiliarSpecialAbilitySchema } from "./types/specialAbility/FamiliarSpecialAbility.js";
+import { validateSchema as validateFatePointSexSpecialAbilitySchema } from "./types/specialAbility/FatePointSexSpecialAbility.js";
+import { validateSchema as validateFatePointSpecialAbilitySchema } from "./types/specialAbility/FatePointSpecialAbility.js";
+import { validateSchema as validateGeneralSpecialAbilitySchema } from "./types/specialAbility/GeneralSpecialAbility.js";
+import { validateSchema as validateKarmaSpecialAbilitySchema } from "./types/specialAbility/KarmaSpecialAbility.js";
+import { validateSchema as validateLiturgicalStyleSpecialAbilitySchema } from "./types/specialAbility/LiturgicalStyleSpecialAbility.js";
+import { validateSchema as validateLycantropicGiftSchema } from "./types/specialAbility/LycantropicGift.js";
+import { validateSchema as validateMagicalSpecialAbilitySchema } from "./types/specialAbility/MagicalSpecialAbility.js";
+import { validateSchema as validateMagicalTraditionSchema } from "./types/specialAbility/MagicalTradition.js";
+import { validateSchema as validateMagicStyleSpecialAbilitySchema } from "./types/specialAbility/MagicStyleSpecialAbility.js";
+import { validateSchema as validatePactGiftSchema } from "./types/specialAbility/PactGift.js";
+import { validateSchema as validateProtectiveWardingCircleSpecialAbilitySchema } from "./types/specialAbility/ProtectiveWardingCircleSpecialAbility.js";
+import { validateSchema as validateSermonSchema } from "./types/specialAbility/Sermon.js";
+import { validateSchema as validateSexSpecialAbilitySchema } from "./types/specialAbility/SexSpecialAbility.js";
+import { validateSchema as validateSikaryanDrainSpecialAbilitySchema } from "./types/specialAbility/SikaryanDrainSpecialAbility.js";
+import { validateSchema as validateSkillStyleSpecialAbilitySchema } from "./types/specialAbility/SkillStyleSpecialAbility.js";
+import { validateSchema as validateLanguageSchema } from "./types/specialAbility/sub/Language.js";
+import { validateSchema as validateScriptSchema } from "./types/specialAbility/sub/Script.js";
+import { validateSchema as validateTradeSecretSchema } from "./types/specialAbility/sub/TradeSecret.js";
+import { validateSchema as validateVampiricGiftSchema } from "./types/specialAbility/VampiricGift.js";
+import { validateSchema as validateVisionSchema } from "./types/specialAbility/Vision.js";
+import { validateSchema as validateSpellSchema } from "./types/Spell.js";
+import { validateSchema as validateStateSchema } from "./types/State.js";
+import { validateSchema as validateTargetCategorySchema } from "./types/TargetCategory.js";
+import { validateSchema as validateArcaneOrbEnchantmentSchema } from "./types/traditionArtifacts/ArcaneOrbEnchantment.js";
+import { validateSchema as validateAttireEnchantmentSchema } from "./types/traditionArtifacts/AttireEnchantment.js";
+import { validateSchema as validateBowlEnchantmentSchema } from "./types/traditionArtifacts/BowlEnchantment.js";
+import { validateSchema as validateCauldronEnchantmentSchema } from "./types/traditionArtifacts/CauldronEnchantment.js";
+import { validateSchema as validateChronicleEnchantmentSchema } from "./types/traditionArtifacts/ChronicleEnchantment.js";
+import { validateSchema as validateDaggerRitualSchema } from "./types/traditionArtifacts/DaggerRitual.js";
+import { validateSchema as validateFoolsHatEnchantmentSchema } from "./types/traditionArtifacts/FoolsHatEnchantment.js";
+import { validateSchema as validateInstrumentEnchantmentSchema } from "./types/traditionArtifacts/InstrumentEnchantment.js";
+import { validateSchema as validateKrallenkettenzauberSchema } from "./types/traditionArtifacts/Krallenkettenzauber.js";
+import { validateSchema as validateOrbEnchantmentSchema } from "./types/traditionArtifacts/OrbEnchantment.js";
+import { validateSchema as validateRingEnchantmentSchema } from "./types/traditionArtifacts/RingEnchantment.js";
+import { validateSchema as validateSickleRitualSchema } from "./types/traditionArtifacts/SickleRitual.js";
+import { validateSchema as validateSpellSwordEnchantmentSchema } from "./types/traditionArtifacts/SpellSwordEnchantment.js";
+import { validateSchema as validateStaffEnchantmentSchema } from "./types/traditionArtifacts/StaffEnchantment.js";
+import { validateSchema as validateAnimalShapeSchema } from "./types/traditionArtifacts/sub/AnimalShape.js";
+import { validateSchema as validateAnimalShapePathSchema } from "./types/traditionArtifacts/sub/AnimalShapePath.js";
+import { validateSchema as validateAnimalShapeSizeSchema } from "./types/traditionArtifacts/sub/AnimalShapeSize.js";
+import { validateSchema as validateBrewSchema } from "./types/traditionArtifacts/sub/Brew.js";
+import { validateSchema as validateToyEnchantmentSchema } from "./types/traditionArtifacts/ToyEnchantment.js";
+import { validateSchema as validateTrinkhornzauberSchema } from "./types/traditionArtifacts/Trinkhornzauber.js";
+import { validateSchema as validateWandEnchantmentSchema } from "./types/traditionArtifacts/WandEnchantment.js";
+import { validateSchema as validateWeaponEnchantmentSchema } from "./types/traditionArtifacts/WeaponEnchantment.js";
+export const typeValidatorMap = {
+    advancedCombatSpecialAbilities: validateAdvancedCombatSpecialAbilitySchema,
+    advancedKarmaSpecialAbilities: validateAdvancedKarmaSpecialAbilitySchema,
+    advancedMagicalSpecialAbilities: validateAdvancedMagicalSpecialAbilitySchema,
+    advancedSkillSpecialAbilities: validateAdvancedSkillSpecialAbilitySchema,
+    advantages: validateAdvantageSchema,
+    ancestorGlyphs: validateAncestorGlyphSchema,
+    animalShapePaths: validateAnimalShapePathSchema,
+    animalShapes: validateAnimalShapeSchema,
+    animalShapeSizes: validateAnimalShapeSizeSchema,
+    animistPowers: validateAnimistPowerSchema,
+    animistPowerTribes: validateTribeSchema,
+    arcaneBardTraditions: validateArcaneBardTraditionSchema,
+    arcaneDancerTraditions: validateArcaneDancerTraditionSchema,
+    arcaneOrbEnchantments: validateArcaneOrbEnchantmentSchema,
+    aspects: validateAspectSchema,
+    attireEnchantments: validateAttireEnchantmentSchema,
+    attributes: validateAttributeSchema,
+    blessedTraditions: validateBlessedTraditionSchema,
+    blessings: validateBlessingSchema,
+    bowlEnchantments: validateBowlEnchantmentSchema,
+    brawlingSpecialAbilities: validateBrawlingSpecialAbilitySchema,
+    brews: validateBrewSchema,
+    cantrips: validateCantripSchema,
+    cauldronEnchantments: validateCauldronEnchantmentSchema,
+    ceremonialItemSpecialAbilities: validateCeremonialItemSpecialAbilitySchema,
+    ceremonies: validateCeremonySchema,
+    chronicleEnchantments: validateChronicleEnchantmentSchema,
+    closeCombatTechniques: validateCloseCombatTechniqueSchema,
+    combatSpecialAbilities: validateCombatSpecialAbilitySchema,
+    combatStyleSpecialAbilities: validateCombatStyleSpecialAbilitySchema,
+    commandSpecialAbilities: validateCommandSpecialAbilitySchema,
+    conditions: validateConditionSchema,
+    continents: validateContinentSchema,
+    cultures: validateCultureSchema,
+    curses: validateCurseSchema,
+    daggerRituals: validateDaggerRitualSchema,
+    derivedCharacteristics: validateDerivedCharacteristicSchema,
+    disadvantages: validateDisadvantageSchema,
+    dominationRituals: validateDominationRitualSchema,
+    elements: validateElementSchema,
+    elvenMagicalSongs: validateElvenMagicalSongSchema,
+    experienceLevels: validateExperienceLevelSchema,
+    eyeColors: validateEyeColorSchema,
+    familiarSpecialAbilities: validateFamiliarSpecialAbilitySchema,
+    familiarsTrickAnimalTypes: validateAnimalTypeSchema,
+    familiarsTricks: validateFamiliarsTrickSchema,
+    fatePointSexSpecialAbilities: validateFatePointSexSpecialAbilitySchema,
+    fatePointSpecialAbilities: validateFatePointSpecialAbilitySchema,
+    focusRules: validateFocusRuleSchema,
+    focusRuleSubjects: validateSubjectSchema,
+    foolsHatEnchantments: validateFoolsHatEnchantmentSchema,
+    generalSpecialAbilities: validateGeneralSpecialAbilitySchema,
+    geodeRituals: validateGeodeRitualSchema,
+    hairColors: validateHairColorSchema,
+    instrumentEnchantments: validateInstrumentEnchantmentSchema,
+    jesterTricks: validateJesterTrickSchema,
+    karmaSpecialAbilities: validateKarmaSpecialAbilitySchema,
+    krallenkettenzauber: validateKrallenkettenzauberSchema,
+    languages: validateLanguageSchema,
+    lessonsCurricula: validateCurriculumSchema,
+    lessonsGuidelines: validateGuidelineSchema,
+    liturgicalChants: validateLiturgicalChantSchema,
+    liturgicalStyleSpecialAbilities: validateLiturgicalStyleSpecialAbilitySchema,
+    locales: validateLocaleSchema,
+    lycantropicGifts: validateLycantropicGiftSchema,
+    magicalDances: validateMagicalDanceSchema,
+    magicalMelodies: validateMagicalMelodySchema,
+    magicalRunes: validateMagicalRuneSchema,
+    magicalSpecialAbilities: validateMagicalSpecialAbilitySchema,
+    magicalTraditions: validateMagicalTraditionSchema,
+    magicStyleSpecialAbilities: validateMagicStyleSpecialAbilitySchema,
+    metaConditions: validateMetaConditionSchema,
+    optionalRules: validateOptionalRuleSchema,
+    orbEnchantments: validateOrbEnchantmentSchema,
+    pactCategories: validatePactCategorySchema,
+    pactGifts: validatePactGiftSchema,
+    patronCategories: validatePatronCategorySchema,
+    patrons: validatePatronSchema,
+    properties: validatePropertySchema,
+    protectiveWardingCircleSpecialAbilities: validateProtectiveWardingCircleSpecialAbilitySchema,
+    publications: validatePublicationSchema,
+    races: validateRaceSchema,
+    rangedCombatTechniques: validateRangedCombatTechniqueSchema,
+    regions: validateRegionSchema,
+    ringEnchantments: validateRingEnchantmentSchema,
+    rituals: validateRitualSchema,
+    scripts: validateScriptSchema,
+    sermons: validateSermonSchema,
+    services: validateServiceSchema,
+    sexPractices: validateSexPracticeSchema,
+    sexSpecialAbilities: validateSexSpecialAbilitySchema,
+    sickleRituals: validateSickleRitualSchema,
+    sikaryanDrainSpecialAbilities: validateSikaryanDrainSpecialAbilitySchema,
+    skillGroups: validateSkillGroupSchema,
+    skillModificationLevels: validateSkillModificationLevelSchema,
+    skills: validateSkillSchema,
+    skillStyleSpecialAbilities: validateSkillStyleSpecialAbilitySchema,
+    socialStatuses: validateSocialStatusSchema,
+    spells: validateSpellSchema,
+    spellSwordEnchantments: validateSpellSwordEnchantmentSchema,
+    staffEnchantments: validateStaffEnchantmentSchema,
+    states: validateStateSchema,
+    targetCategories: validateTargetCategorySchema,
+    toyEnchantments: validateToyEnchantmentSchema,
+    tradeSecrets: validateTradeSecretSchema,
+    trinkhornzauber: validateTrinkhornzauberSchema,
+    vampiricGifts: validateVampiricGiftSchema,
+    visions: validateVisionSchema,
+    wandEnchantments: validateWandEnchantmentSchema,
+    weaponEnchantments: validateWeaponEnchantmentSchema,
+    zibiljaRituals: validateZibiljaRitualSchema,
+};

package/lib/main.d.ts

@@ -1 +1,17 @@
+import { DefinedError } from "ajv";
+import { TypeMap } from "./config.js";
+declare type Result = {
+    tag: "Ok";
+    value: {
+        [K in keyof TypeMap]: TypeMap[K][];
+    };
+} | {
+    tag: "Error";
+    errors: Record<string, DefinedError[]>;
+};
+export declare type EntityDirectoryPaths = {
+    [K in keyof TypeMap]: string;
+};
+export declare const validate: (entityDirPaths: EntityDirectoryPaths, checkIntegrity: boolean) => Promise<Result>;
+export declare const printErrors: (errorsByFile: Record<string, DefinedError[]>) => string;
 export {};

package/lib/main.js

@@ -1 +1,111 @@
-export {};
+import Ajv from "ajv";
+import addFormats from "ajv-formats";
+import { lstat, readdir, readFile } from "fs/promises";
+import { join } from "path";
+import YAML from "yaml";
+import { jsonSchemaDir } from "../build/directories.js";
+import { typeValidatorMap } from "./config.js";
+const readdirRecursive = async (dirPath) => {
+    const directoryEntries = await readdir(dirPath, { withFileTypes: true });
+    const flattenedRecursivePaths = await Promise.all(directoryEntries.map(async (dirEntry) => {
+        const absoluteEntryPath = join(dirPath, dirEntry.name);
+        if (dirEntry.isDirectory()) {
+            return await readdirRecursive(absoluteEntryPath);
+        }
+        else if (dirEntry.isFile()) {
+            return [absoluteEntryPath];
+        }
+        else {
+            return [];
+        }
+    }));
+    return flattenedRecursivePaths.flat();
+};
+const registerAllJsonSchemaDocuments = async (validator) => {
+    const allJsonSchemaFilePaths = await readdirRecursive(jsonSchemaDir);
+    const readFileAsUtf8 = (path) => readFile(path, "utf-8");
+    const readFilesAsUtf8 = (paths) => Promise.all(paths.map(readFileAsUtf8));
+    const parseJson = (json) => JSON.parse(json);
+    const registerSchemaInValidator = (jsonSchema) => { validator.addSchema(jsonSchema); };
+    (await readFilesAsUtf8(allJsonSchemaFilePaths))
+        .map(parseJson)
+        .forEach(registerSchemaInValidator);
+};
+const readDataFileAssocsFromDirectory = async (dirPath) => await Promise.all((await readdir(dirPath)).map(async (fileName) => {
+    const filePath = join(dirPath, fileName);
+    try {
+        const fileContent = YAML.parse(await readFile(join(dirPath, fileName), "utf-8"));
+        return [filePath, fileContent];
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            error.message = `in "${filePath}":\n  ${error.message}`;
+        }
+        return [filePath, null];
+    }
+}));
+const validateAllFromType = async (validator, typeName, path) => {
+    const isFile = (await lstat(path)).isFile();
+    const typeValidator = typeValidatorMap[typeName];
+    if (isFile) {
+        return [typeName, { [path]: typeValidator(validator, await readFile(path, "utf-8"), path) }];
+    }
+    else {
+        const dataFiles = await readDataFileAssocsFromDirectory(path);
+        return [
+            typeName,
+            Object.fromEntries(dataFiles.map(([filePath, fileContent]) => [filePath, typeValidator(validator, fileContent, filePath)]))
+        ];
+    }
+};
+const rawResultMapToResult = (rawResultMap) => Object.entries(rawResultMap).reduce((result, [typeName, typeResults]) => Object.entries(typeResults).reduce((outerResult, [filePath, fileResult]) => {
+    if (outerResult.tag === "Ok" && fileResult.tag === "Ok") {
+        return {
+            tag: "Ok",
+            value: {
+                ...outerResult.value,
+                [typeName]: [...(outerResult.value[typeName] ?? []), fileResult.value]
+            }
+        };
+    }
+    else if (outerResult.tag === "Ok" && fileResult.tag === "Error") {
+        return {
+            tag: "Error",
+            errors: {
+                [filePath]: fileResult.errors
+            }
+        };
+    }
+    else if (outerResult.tag === "Error" && fileResult.tag === "Error") {
+        return {
+            tag: "Error",
+            errors: {
+                ...outerResult.errors,
+                [filePath]: [...(outerResult.errors[filePath] ?? []), ...fileResult.errors]
+            }
+        };
+    }
+    else {
+        return outerResult;
+    }
+}, result), ({
+    tag: "Ok",
+    value: {}
+}));
+export const validate = async (entityDirPaths, checkIntegrity) => {
+    const validator = new Ajv();
+    addFormats(validator);
+    await registerAllJsonSchemaDocuments(validator);
+    const rawResultMap = Object.fromEntries((await Promise.all(Object.entries(entityDirPaths)
+        .map(async ([typeName, path]) => validateAllFromType(validator, typeName, path)))));
+    return rawResultMapToResult(rawResultMap);
+};
+export const printErrors = (errorsByFile) => Object.entries(errorsByFile)
+    .flatMap(([filePath, errors]) => errors.map(error => {
+    const pathSegments = [filePath, ...error.instancePath.split("/").slice(1)];
+    return [
+        ...pathSegments.map((segment, i) => `${" ".repeat(i * 2)}in "${segment}":`),
+        `${" ".repeat(pathSegments.length * 2)}${error.message ?? ""}`
+    ].join("\n");
+}))
+    .join("\n\n");