@optolith/database-schema 0.42.1

package/lib/cache/ancestorBloodAdvantages.d.ts

@@ -0,0 +1,4 @@
+import type { Advantage_ID } from "../../gen/types.js";
+import type { CacheBuilder } from "./internal.ts";
+export type AncestorBloodAdvantagesCache = Advantage_ID[];
+export declare const buildAncestorBloodAdvantagesCache: CacheBuilder<AncestorBloodAdvantagesCache>;

package/lib/cache/ancestorBloodAdvantages.js

@@ -0,0 +1,13 @@
+export const buildAncestorBloodAdvantagesCache = database => database
+    .getAllInstanceContainersOfEntity("Advantage")
+    .filter(({ content }) => content.prerequisites?.some(p => {
+    switch (p.prerequisite.kind) {
+        case "Single":
+            return p.prerequisite.Single.kind === "NoOtherAncestorBloodAdvantage";
+        case "Disjunction":
+            return p.prerequisite.Disjunction.list.some(d => d.kind === "NoOtherAncestorBloodAdvantage");
+        case "Group":
+            return p.prerequisite.Group.list.some(g => g.kind === "NoOtherAncestorBloodAdvantage");
+    }
+}))
+    .map(({ id }) => id);

package/lib/cache/index.d.ts

@@ -0,0 +1,31 @@
+import type { TSONDB } from "tsondb";
+import type { TSONDBTypes } from "../main.ts";
+import { type ActivatableSelectOptionsCache, type ResolvedSelectOption, type ResolvedSelectOptionIdentifier } from "./activatableSelectOptions.ts";
+import { type AncestorBloodAdvantagesCache } from "./ancestorBloodAdvantages.ts";
+import { type MagicalAndBlessedAdvantagesAndDisadvantagesCache } from "./magicalAndBlessedAdvantagesAndDisadvantages.ts";
+import { type NewApplicationsAndUsesCache, type ResolvedNewSkillApplication, type ResolvedSkillUse } from "./newApplicationsAndUses.ts";
+/**
+ * Identifiers of specific entries in the database that are used for creating the cache.
+ */
+export type IdMap = {
+    Advantage: Record<"Blessed" | "Spellcaster", string>;
+    MagicalSpecialAbility: Record<"PropertyKnowledge", string>;
+    KarmaSpecialAbility: Record<"AspectKnowledge", string>;
+};
+/**
+ * The cache object containing all precomputed data.
+ */
+export type Cache = {
+    activatableSelectOptions: ActivatableSelectOptionsCache;
+    sncestorBloodAdvantages: AncestorBloodAdvantagesCache;
+    magicalAndBlessedAdvantagesAndDisadvantages: MagicalAndBlessedAdvantagesAndDisadvantagesCache;
+    newApplicationsAndUses: NewApplicationsAndUsesCache;
+};
+export type { ActivatableSelectOptionsCache, AncestorBloodAdvantagesCache, MagicalAndBlessedAdvantagesAndDisadvantagesCache, NewApplicationsAndUsesCache, ResolvedNewSkillApplication, ResolvedSelectOption, ResolvedSelectOptionIdentifier, ResolvedSkillUse, };
+/**
+ * Creates the cache by precomputing all necessary data from the database.
+ * @param db The TSONDB instance containing the database.
+ * @param idMap An object containing identifiers of specific entries in the database that are used for creating the cache.
+ * @returns The created cache object.
+ */
+export declare const createCache: (db: TSONDB<TSONDBTypes>, idMap: IdMap) => Cache;

package/lib/cache/index.js

@@ -0,0 +1,22 @@
+import { activatableSelectOptionsCacheBuilder, } from "./activatableSelectOptions.js";
+import { buildAncestorBloodAdvantagesCache, } from "./ancestorBloodAdvantages.js";
+import { buildMagicalAndBlessedAdvantagesAndDisadvantagesCache, } from "./magicalAndBlessedAdvantagesAndDisadvantages.js";
+import { buildNewApplicationsAndUsesCache, } from "./newApplicationsAndUses.js";
+/**
+ * Creates the cache by precomputing all necessary data from the database.
+ * @param db The TSONDB instance containing the database.
+ * @param idMap An object containing identifiers of specific entries in the database that are used for creating the cache.
+ * @returns The created cache object.
+ */
+export const createCache = (db, idMap) => {
+    const activatableSelectOptions = activatableSelectOptionsCacheBuilder(db, idMap);
+    const sncestorBloodAdvantages = buildAncestorBloodAdvantagesCache(db, idMap);
+    const magicalAndBlessedAdvantagesAndDisadvantages = buildMagicalAndBlessedAdvantagesAndDisadvantagesCache(db, idMap);
+    const newApplicationsAndUses = buildNewApplicationsAndUsesCache(db, idMap, activatableSelectOptions);
+    return {
+        activatableSelectOptions,
+        sncestorBloodAdvantages,
+        magicalAndBlessedAdvantagesAndDisadvantages,
+        newApplicationsAndUses,
+    };
+};

package/lib/cache/internal.d.ts

@@ -0,0 +1,4 @@
+import type { TSONDB } from "tsondb";
+import type { TSONDBTypes } from "../main.ts";
+import type { IdMap } from "./index.ts";
+export type CacheBuilder<T = unknown, Args extends unknown[] = []> = (db: TSONDB<TSONDBTypes>, idMap: IdMap, ...args: Args) => T;

package/lib/cache/internal.js

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

package/lib/cache/magicalAndBlessedAdvantagesAndDisadvantages.d.ts

@@ -0,0 +1,3 @@
+import type { CacheBuilder } from "./internal.ts";
+export type MagicalAndBlessedAdvantagesAndDisadvantagesCache = Record<"Advantage" | "Disadvantage", Record<"Magical" | "Blessed", string[]>>;
+export declare const buildMagicalAndBlessedAdvantagesAndDisadvantagesCache: CacheBuilder<MagicalAndBlessedAdvantagesAndDisadvantagesCache>;

package/lib/cache/magicalAndBlessedAdvantagesAndDisadvantages.js

@@ -0,0 +1,103 @@
+import { assertExhaustive } from "@elyukai/utils/typeSafety";
+const getAdvantageId = (idMap, type) => {
+    switch (type) {
+        case "Magical":
+            return idMap.Advantage.Spellcaster;
+        case "Blessed":
+            return idMap.Advantage.Blessed;
+        default:
+            return assertExhaustive(type);
+    }
+};
+const isRatedFor = (type, ratedId) => {
+    switch (ratedId.kind) {
+        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 = (idMap, type, prerequisite, getById, traversedIds) => {
+    switch (prerequisite.kind) {
+        case "Activatable": {
+            if (prerequisite.Activatable.id.kind === "Advantage" &&
+                prerequisite.Activatable.id.Advantage === getAdvantageId(idMap, type) &&
+                prerequisite.Activatable.active) {
+                return true;
+            }
+            const entry = getById(prerequisite.Activatable.id);
+            return entry !== undefined && is(idMap, 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 "Enhancement":
+        case "Text":
+        case "NoOtherAncestorBloodAdvantage":
+        case "SexualCharacteristic":
+            return false;
+        default:
+            return assertExhaustive(prerequisite);
+    }
+};
+const is = (idMap, type, entry, getById, traversedIds) => {
+    if (!entry.content.prerequisites || traversedIds.includes(entry.id)) {
+        return false;
+    }
+    const newTraversedIds = [...traversedIds, entry.id];
+    return (entry.content.prerequisites !== undefined &&
+        entry.content.prerequisites.some(prerequisite => {
+            switch (prerequisite.prerequisite.kind) {
+                case "Single":
+                    return isPrerequisiteFor(idMap, type, prerequisite.prerequisite.Single, getById, newTraversedIds);
+                case "Disjunction":
+                    return prerequisite.prerequisite.Disjunction.list.some(p => isPrerequisiteFor(idMap, type, p, getById, newTraversedIds));
+                case "Group":
+                    return prerequisite.prerequisite.Group.list.some(p => isPrerequisiteFor(idMap, type, p, getById, newTraversedIds));
+                default:
+                    return assertExhaustive(prerequisite.prerequisite);
+            }
+        }));
+};
+const entityKeyMap = {
+    Advantage: null,
+    Disadvantage: null,
+};
+const typeKeyMap = {
+    Magical: null,
+    Blessed: null,
+};
+const collectIds = (entity, type, database, idMap) => database
+    .getAllInstanceContainersOfEntity(entity)
+    .filter(entry => is(idMap, type, entry, database.getInstanceContainerOfEntityById.bind(database), []))
+    .map(({ id }) => id);
+export const buildMagicalAndBlessedAdvantagesAndDisadvantagesCache = (database, idMap) => {
+    return Object.fromEntries(Object.keys(entityKeyMap).map((entity) => [
+        entity,
+        Object.fromEntries(Object.keys(typeKeyMap).map((type) => [
+            type,
+            collectIds(entity, type, database, idMap),
+        ])),
+    ]));
+};

package/lib/cache/newApplicationsAndUses.d.ts

@@ -0,0 +1,22 @@
+import type { ActivatableIdentifier, NewSkillApplication, NewSkillApplicationOrUseParentIdentifier, Skill_ID, SkillUse } from "../../gen/types.js";
+import type { ActivatableSelectOptionsCache } from "./activatableSelectOptions.ts";
+import type { CacheBuilder } from "./internal.ts";
+export type ResolvedNewSkillApplication = {
+    id: string;
+    content: Omit<NewSkillApplication, "parent"> & {
+        parent: NewSkillApplicationOrUseParentIdentifier | ActivatableIdentifier;
+    };
+};
+export type ResolvedSkillUse = {
+    id: string;
+    content: Omit<SkillUse, "parent"> & {
+        parent: NewSkillApplicationOrUseParentIdentifier | ActivatableIdentifier;
+    };
+};
+export type NewApplicationsAndUsesCache = {
+    newApplications: Record<Skill_ID, ResolvedNewSkillApplication[]>;
+    uses: Record<Skill_ID, ResolvedSkillUse[]>;
+};
+export declare const buildNewApplicationsAndUsesCache: CacheBuilder<NewApplicationsAndUsesCache, [
+    generatedSelectOptions: ActivatableSelectOptionsCache
+]>;

package/lib/cache/newApplicationsAndUses.js

@@ -0,0 +1,12 @@
+const groupByAffectedSkill = (entries, prev = {}) => entries.reduce((acc, entry) => entry.content.skills.reduce((acc1, skillId) => ({ ...acc1, [skillId]: [...(acc1[skillId] ?? []), entry] }), acc), prev);
+const addGeneratedEntries = (generatedSelectOptions, prev) => Object.values(generatedSelectOptions).reduce((acc, byInstance) => Object.values(byInstance).reduce((acc1, resolvedSelectOptions) => resolvedSelectOptions.reduce((acc2, selectOption) => ({
+    newApplications: groupByAffectedSkill(selectOption.newApplications, acc2.newApplications),
+    uses: groupByAffectedSkill(selectOption.uses, acc2.uses),
+}), acc1), acc), prev);
+export const buildNewApplicationsAndUsesCache = (database, _idMap, generatedSelectOptions) => {
+    const cache = {
+        newApplications: groupByAffectedSkill(database.getAllInstanceContainersOfEntity("NewSkillApplication")),
+        uses: groupByAffectedSkill(database.getAllInstanceContainersOfEntity("SkillUse")),
+    };
+    return addGeneratedEntries(generatedSelectOptions, cache);
+};

package/lib/main.d.ts

@@ -0,0 +1,17 @@
+import { Schema } from "tsondb/schema";
+import type { ChildEntityMap, EntityMap, EnumMap, TypeAliasMap } from "../gen/types.js";
+declare module "tsondb/schema/gen" {
+    interface Register {
+        entityMap: EntityMap;
+        childEntityMap: ChildEntityMap;
+        enumMap: EnumMap;
+        typeAliasMap: TypeAliasMap;
+    }
+}
+export interface TSONDBTypes {
+    entityMap: EntityMap;
+    childEntityMap: ChildEntityMap;
+    enumMap: EnumMap;
+    typeAliasMap: TypeAliasMap;
+}
+export declare const schema: Schema<TSONDBTypes>;

package/lib/main.js

@@ -0,0 +1,226 @@
+import { Schema } from "tsondb/schema";
+import * as Types from "./types/index.js";
+export const schema = new Schema([
+    Types.AdvancedCombatSpecialAbility,
+    Types.AdvancedKarmaSpecialAbility,
+    Types.AdvancedMagicalSpecialAbility,
+    Types.AdvancedSkillSpecialAbility,
+    Types.Advantage,
+    Types.AlternativeRule,
+    Types.Ammunition,
+    Types.AncestorGlyph,
+    Types.Animal,
+    Types.AnimalCare,
+    Types.AnimalDisease,
+    Types.AnimalShape,
+    Types.AnimalShapePath,
+    Types.AnimalShapeSize,
+    Types.AnimalType,
+    Types.AnimistPower,
+    Types.ArcaneBardTradition,
+    Types.ArcaneDancerTradition,
+    Types.ArcaneOrbEnchantment,
+    Types.Armor,
+    Types.ArmorType,
+    Types.Aspect,
+    Types.AttireEnchantment,
+    Types.Attribute,
+    Types.BandageOrRemedy,
+    Types.Bannzeichen,
+    Types.Beutelzauber,
+    Types.BlessedTradition,
+    Types.Blessing,
+    Types.Book,
+    Types.BowlEnchantment,
+    Types.BrawlingSpecialAbility,
+    Types.Brew,
+    Types.Cantrip,
+    Types.CauldronEnchantment,
+    Types.CeremonialItem,
+    Types.CeremonialItemSpecialAbility,
+    Types.Ceremony,
+    Types.ChronicleEnchantment,
+    Types.CloseCombatTechnique,
+    Types.Clothes,
+    Types.ClothingPackage,
+    Types.CombatSpecialAbility,
+    Types.CombatStyleSpecialAbility,
+    Types.CommandSpecialAbility,
+    Types.Condition,
+    Types.Container,
+    Types.Continent,
+    Types.CoreRule,
+    Types.Culture,
+    Types.Curriculum,
+    Types.Curse,
+    Types.DaggerRitual,
+    Types.DerivedCharacteristic,
+    Types.Disadvantage,
+    Types.Disease,
+    Types.DominationRitual,
+    Types.Element,
+    Types.Elixir,
+    Types.ElvenMagicalSong,
+    Types.EquipmentOfBlessedOnes,
+    Types.EquipmentPackage,
+    Types.ExperienceLevel,
+    Types.EyeColor,
+    Types.FamiliarSpecialAbility,
+    Types.FamiliarsTrick,
+    Types.FatePointSexSpecialAbility,
+    Types.FatePointSpecialAbility,
+    Types.FocusRule,
+    Types.FoolsHatEnchantment,
+    Types.GemOrPreciousStone,
+    Types.GeneralSpecialAbility,
+    Types.GeodeRitual,
+    Types.GoblinRitual,
+    Types.Guideline,
+    Types.HairColor,
+    Types.Haubenzauber,
+    Types.HomunculusType,
+    Types.IlluminationLightSource,
+    Types.IlluminationRefillOrSupply,
+    Types.InstrumentEnchantment,
+    Types.JesterTrick,
+    Types.Jewelry,
+    Types.KarmaSpecialAbility,
+    Types.Krallenkettenzauber,
+    Types.Kristallkugelzauber,
+    Types.Laboratory,
+    Types.Language,
+    Types.Liebesspielzeug,
+    Types.LiturgicalChant,
+    Types.LiturgicalStyleSpecialAbility,
+    Types.LuxuryGood,
+    Types.LycantropicGift,
+    Types.MagicalArtifact,
+    Types.MagicalDance,
+    Types.MagicalMelody,
+    Types.MagicalRune,
+    Types.MagicalSign,
+    Types.MagicalSpecialAbility,
+    Types.MagicalTradition,
+    Types.MagicStyleSpecialAbility,
+    Types.MetaCondition,
+    Types.MusicalInstrument,
+    Types.Newspaper,
+    Types.OptionalRule,
+    Types.OrbEnchantment,
+    Types.OrienteeringAid,
+    Types.PactCategory,
+    Types.PactGift,
+    Types.Patron,
+    Types.PatronCategory,
+    Types.PersonalityTrait,
+    Types.PlayerType,
+    Types.Poison,
+    Types.Profession,
+    Types.Property,
+    Types.ProtectiveWardingCircleSpecialAbility,
+    Types.Publication,
+    Types.Race,
+    Types.RangedCombatTechnique,
+    Types.Reach,
+    Types.Region,
+    Types.RingEnchantment,
+    Types.Ritual,
+    Types.RopeOrChain,
+    Types.Script,
+    Types.Sermon,
+    Types.Service,
+    Types.SexPractice,
+    Types.SexSpecialAbility,
+    Types.SickleRitual,
+    Types.SikaryanDrainSpecialAbility,
+    Types.Skill,
+    Types.SkillGroup,
+    Types.SkillModificationLevel,
+    Types.SkillStyleSpecialAbility,
+    Types.SocialStatus,
+    Types.Spell,
+    Types.SpellSwordEnchantment,
+    Types.StaffEnchantment,
+    Types.State,
+    Types.Stationery,
+    Types.Subject,
+    Types.Talisman,
+    Types.TargetCategory,
+    Types.ThievesTool,
+    Types.ToolOfTheTrade,
+    Types.ToyEnchantment,
+    Types.TradeSecret,
+    Types.TravelGearOrTool,
+    Types.Tribe,
+    Types.Trinkhornzauber,
+    Types.VampiricGift,
+    Types.Vehicle,
+    Types.Vision,
+    Types.WandEnchantment,
+    Types.Weapon,
+    Types.WeaponAccessory,
+    Types.WeaponEnchantment,
+    Types.WorkingSupernaturalCreature,
+    Types.ZibiljaRitual,
+], Types.Locale);
+// /**
+//  * A dictionary of cache types and their associated location.
+//  */
+// export type CachePaths = {
+//   [K in keyof CacheMap]: string
+// }
+// export type CacheOptions = {
+//   /**
+//    * Whether to pretty-print the JSON. Default is `false`.
+//    */
+//   pretty?: boolean
+// }
+// /**
+//  * Builds the cache and writes it to the specified paths in JSON format.
+//  * @param cachePaths The absolute paths to write each cache to.
+//  * @param validResults The data to build the cache from. Usually the result of
+//  * `getAllValidData`.
+//  * @param options Configuration options for building the cache.
+//  */
+// export const buildCache = async (
+//   cachePaths: CachePaths,
+//   validResults: ValidResults,
+//   options: CacheOptions = {}
+// ): Promise<void> => {
+//   const { pretty = false } = options
+//   const activatableSelectOptionsCache = cacheMap.activatableSelectOptions.builder(validResults)
+//   const ancestorBloodAdvantagesCache = cacheMap.ancestorBloodAdvantages.builder(validResults)
+//   const magicalAndBlessedAdvantagesAndDisadvantagesCache =
+//     cacheMap.magicalAndBlessedAdvantagesAndDisadvantages.builder(validResults)
+//   const newApplicationsAndUsesCache = cacheMap.newApplicationsAndUses.builder(
+//     validResults,
+//     activatableSelectOptionsCache
+//   )
+//   const cacheData: CacheMap = {
+//     activatableSelectOptions: activatableSelectOptionsCache,
+//     ancestorBloodAdvantages: ancestorBloodAdvantagesCache,
+//     magicalAndBlessedAdvantagesAndDisadvantages: magicalAndBlessedAdvantagesAndDisadvantagesCache,
+//     newApplicationsAndUses: newApplicationsAndUsesCache,
+//   }
+//   for (const [cacheName, cachePath] of Object.entries(cachePaths)) {
+//     await mkdir(dirname(cachePath), { recursive: true })
+//     await writeFile(
+//       cachePath,
+//       JSON.stringify(cacheData[cacheName as keyof CachePaths], null, pretty ? 2 : undefined),
+//       "utf-8"
+//     )
+//   }
+// }
+// /**
+//  * Reads the cache from the specified paths in JSON format.
+//  * @param cachePaths The absolute paths to read each cache from.
+//  * @returns
+//  */
+// export const getCache = async (cachePaths: CachePaths): Promise<CacheMap> => {
+//   const cache: Partial<CacheMap> = {}
+//   for (const [cacheName, cachePath] of Object.entries(cachePaths)) {
+//     const cacheData = JSON.parse(await readFile(cachePath, "utf-8"))
+//     cache[cacheName as keyof CacheMap] = cacheData
+//   }
+//   return cache as CacheMap
+// }

package/lib/test.d.ts

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

package/lib/test.js

@@ -0,0 +1,11 @@
+import { stderr } from "node:process";
+import { styleText } from "node:util";
+// importing the main file will run the schema checks
+import("./main.js")
+    .then(() => {
+    console.log(styleText("green", "Schema is valid"));
+})
+    .catch((err) => {
+    console.error(styleText("red", err instanceof Error ? err.message : String(err), { stream: stderr }));
+    process.exitCode = 1;
+});