@optolith/database-schema 0.77.0 → 0.78.0

package/lib/types/_ActivatableSelectOptions.d.ts

@@ -1,4 +1,6 @@
 import * as DB from "tsondb/schema/dsl";
+import { Case, type GetAllChildInstanceContainersForParent, type GetInstanceById } from "tsondb/schema/gen";
+import type { ActivatableIdentifier, ProfessionSpecialAbilityOption, RequirableSelectOptionIdentifier } from "../../gen/types.js";
 export declare const select_options: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"SelectOptions", DB.Object<{
     derived: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SelectOptionCategory", {
         Blessings: DB.EnumCase<null>;
@@ -1223,3 +1225,11 @@ export declare const explicit_select_options: DB.MemberDecl<DB.ChildEntities<DB.
         }>, []>>>, []>>, false>;
     }>, true>;
 }, "parent">>, true>;
+/**
+ * Stub for once option rules are formalized in the database schema.
+ */
+export declare const verifyOptionsForActivatableEntry: (value: {
+    id: ActivatableIdentifier | Case<"Enhancement", string>;
+    level?: number;
+    options?: (RequirableSelectOptionIdentifier | ProfessionSpecialAbilityOption)[];
+}, getInstanceById: GetInstanceById, getAllChildInstancesForParent: GetAllChildInstanceContainersForParent) => string[];

package/lib/types/_ActivatableSelectOptions.js

@@ -1,4 +1,6 @@
+import { isEmpty, isNotEmpty } from "@elyukai/utils/array/nonEmpty";
 import * as DB from "tsondb/schema/dsl";
+import { Case, fromUniformCase, } from "tsondb/schema/gen";
 import { NestedTranslationMap } from "./Locale.js";
 import { SelectOptionCategory } from "./_ActivatableSelectOptionCategory.js";
 import { NewSkillApplication, SkillUse } from "./_ActivatableSkillApplicationsAndUses.js";
@@ -216,3 +218,41 @@ Note that this is only a full definition of options for simple logic that can be
 //     ]
 //   }
 // },
+/**
+ * Stub for once option rules are formalized in the database schema.
+ */
+export const verifyOptionsForActivatableEntry = (value, getInstanceById, getAllChildInstancesForParent) => {
+    if (value.id.kind === "Enhancement") {
+        return [];
+    }
+    const referencedInstance = getInstanceById(value.id);
+    if (!referencedInstance) {
+        return [
+            `Referenced instance of entity ${value.id.kind} with id ${fromUniformCase(value.id)} not found.`,
+        ];
+    }
+    const generalSelectOptions = getAllChildInstancesForParent("GeneralSelectOption", value.id);
+    const errorMessages = [];
+    if (!("levels" in referencedInstance && typeof referencedInstance.levels === "number") &&
+        value.level !== undefined) {
+        errorMessages.push(`The referenced instance of entity ${value.id.kind} with id ${fromUniformCase(value.id)} does not have levels, but a level was specified in the prerequisite.`);
+    }
+    if ((("select_options" in referencedInstance &&
+        referencedInstance.select_options?.derived !== undefined) ||
+        isNotEmpty(generalSelectOptions)) &&
+        (value.options === undefined || isEmpty(value.options))) {
+        errorMessages.push(`The referenced instance of entity ${value.id.kind} with id ${fromUniformCase(value.id)} has select options, but no options were specified in the prerequisite.`);
+    }
+    for (const option of value.options ?? []) {
+        if (option.kind === "General") {
+            const referencedOption = getInstanceById(Case("GeneralSelectOption", option.General));
+            if (!referencedOption) {
+                errorMessages.push(`Referenced select option of entity GeneralSelectOption with id ${fromUniformCase(option)} not found.`);
+            }
+            if (referencedOption?.parent !== value.id) {
+                errorMessages.push(`Referenced select option of entity GeneralSelectOption with id ${fromUniformCase(option)} does not belong to the instance of entity ${value.id.kind} with id ${fromUniformCase(value.id)}.`);
+            }
+        }
+    }
+    return [];
+};

package/lib/types/_Identifier.d.ts

@@ -61,6 +61,7 @@ export declare const ElementIdentifier: () => R;
 export declare const ElixirIdentifier: () => R;
 export declare const ElvenMagicalSongIdentifier: () => R;
 export declare const EnhancementIdentifier: () => R;
+export declare const EquipmentCategoryIdentifier: () => R;
 export declare const EquipmentOfBlessedOnesIdentifier: () => R;
 export declare const ExperienceLevelIdentifier: () => R;
 export declare const EyeColorIdentifier: () => R;
@@ -85,6 +86,7 @@ export declare const IlluminationLightSourceIdentifier: () => R;
 export declare const IlluminationRefillOrSupplyIdentifier: () => R;
 export declare const InfluenceIdentifier: () => R;
 export declare const InstrumentEnchantmentIdentifier: () => R;
+export declare const ItemIdentifier: () => R;
 export declare const JesterTrickIdentifier: () => R;
 export declare const JewelryIdentifier: () => R;
 export declare const KarmaSpecialAbilityIdentifier: () => R;

package/lib/types/_Identifier.js

@@ -30,12 +30,14 @@ import { Clothes } from "./equipment/item/Clothes.js";
 import { ClothingPackage } from "./equipment/item/ClothingPackage.js";
 import { Container } from "./equipment/item/Container.js";
 import { Elixir } from "./equipment/item/Elixir.js";
+import { EquipmentCategory } from "./equipment/item/EquipmentCategory.js";
 import { EquipmentOfBlessedOnes } from "./equipment/item/EquipmentOfBlessedOnes.js";
 import { GemOrPreciousStone } from "./equipment/item/GemOrPreciousStone.js";
 import { HerbalAid } from "./equipment/item/HerbalAid.js";
 import { HerbalPreservation } from "./equipment/item/HerbalPreservation.js";
 import { IlluminationLightSource } from "./equipment/item/IlluminationLightSource.js";
 import { IlluminationRefillOrSupply } from "./equipment/item/IlluminationRefillOrSupply.js";
+import { Item } from "./equipment/item/Item.js";
 import { Jewelry } from "./equipment/item/Jewelry.js";
 import { Laboratory } from "./equipment/item/Laboratory.js";
 import { Liebesspielzeug } from "./equipment/item/Liebesspielzeug.js";
@@ -225,6 +227,7 @@ export const ElementIdentifier = () => R(Element);
 export const ElixirIdentifier = () => R(Elixir);
 export const ElvenMagicalSongIdentifier = () => R(ElvenMagicalSong);
 export const EnhancementIdentifier = () => R(Enhancement);
+export const EquipmentCategoryIdentifier = () => R(EquipmentCategory);
 export const EquipmentOfBlessedOnesIdentifier = () => R(EquipmentOfBlessedOnes);
 export const ExperienceLevelIdentifier = () => R(ExperienceLevel);
 export const EyeColorIdentifier = () => R(EyeColor);
@@ -249,6 +252,7 @@ export const IlluminationLightSourceIdentifier = () => R(IlluminationLightSource
 export const IlluminationRefillOrSupplyIdentifier = () => R(IlluminationRefillOrSupply);
 export const InfluenceIdentifier = () => R(Influence);
 export const InstrumentEnchantmentIdentifier = () => R(InstrumentEnchantment);
+export const ItemIdentifier = () => R(Item);
 export const JesterTrickIdentifier = () => R(JesterTrick);
 export const JewelryIdentifier = () => R(Jewelry);
 export const KarmaSpecialAbilityIdentifier = () => R(KarmaSpecialAbility);

package/lib/types/equipment/item/BandageOrRemedy.js

@@ -41,7 +41,7 @@ export const BandageOrRemedy = DB.Entity(import.meta.url, {
             return checkWeaponCombatTechniqueIntegrity({
                 ...rest,
                 instanceContent: instanceContent.combat_use.Weapon,
-            }, { secondary: true });
+            });
         }
         return [];
     },

package/lib/types/equipment/item/CeremonialItem.js

@@ -46,7 +46,7 @@ export const CeremonialItem = DB.Entity(import.meta.url, {
             return checkWeaponCombatTechniqueIntegrity({
                 ...rest,
                 instanceContent: instanceContent.combat_use.Weapon,
-            }, { secondary: true });
+            });
         }
         return [];
     },

package/lib/types/equipment/item/Clothes.js

@@ -41,7 +41,7 @@ export const Clothes = DB.Entity(import.meta.url, {
             return checkWeaponCombatTechniqueIntegrity({
                 ...rest,
                 instanceContent: instanceContent.combat_use.Weapon,
-            }, { secondary: true });
+            });
         }
         return [];
     },

package/lib/types/equipment/item/Container.js

@@ -41,7 +41,7 @@ export const Container = DB.Entity(import.meta.url, {
             return checkWeaponCombatTechniqueIntegrity({
                 ...rest,
                 instanceContent: instanceContent.combat_use.Weapon,
-            }, { secondary: true });
+            });
         }
         return [];
     },

package/lib/types/equipment/item/EquipmentCategory.d.ts

@@ -0,0 +1,121 @@
+import type { NonEmptyArray } from "@elyukai/utils/array/nonEmpty";
+import * as DB from "tsondb/schema/dsl";
+import type { Case } from "tsondb/schema/gen";
+import type { DefaultEquipmentCategoryTypeRules, EquipmentCategory as EquipmentCategoryType, ValueRule } from "../../../../gen/types.js";
+declare const ValueRule: DB.Enum<"ValueRule", {
+    Required: DB.EnumCase<null>;
+    Optional: DB.EnumCase<null>;
+    Prohibited: DB.EnumCase<null>;
+}, []>;
+declare const EquipmentCategoryType: DB.Enum<"EquipmentCategoryType", {
+    Default: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"DefaultEquipmentCategoryTypeRules", DB.Object<{
+        combatValues: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"AllowedCombatValues", DB.Object<{
+            isWeaponAllowed: DB.MemberDecl<DB.Boolean, true>;
+            isArmorAllowed: DB.MemberDecl<DB.Boolean, true>;
+        }>, []>>, true>;
+        restrictedTo: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ValueRule", {
+            Required: DB.EnumCase<null>;
+            Optional: DB.EnumCase<null>;
+            Prohibited: DB.EnumCase<null>;
+        }, []>>, true>;
+        structurePoints: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ValueRule", {
+            Required: DB.EnumCase<null>;
+            Optional: DB.EnumCase<null>;
+            Prohibited: DB.EnumCase<null>;
+        }, []>>, true>;
+        weight: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ValueRule", {
+            Required: DB.EnumCase<null>;
+            Optional: DB.EnumCase<null>;
+            Prohibited: DB.EnumCase<null>;
+        }, []>>, true>;
+        complexity: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ValueRule", {
+            Required: DB.EnumCase<null>;
+            Optional: DB.EnumCase<null>;
+            Prohibited: DB.EnumCase<null>;
+        }, []>>, true>;
+    }>, []>>>;
+    Special: DB.EnumCase<DB.IncludeIdentifier<[], DB.Enum<"SpecialEquipmentCategoryEntity", {
+        AnimalCare: DB.EnumCase<null>;
+        Book: DB.EnumCase<null>;
+        Elixir: DB.EnumCase<null>;
+        GemOrPreciousStone: DB.EnumCase<null>;
+        Newspaper: DB.EnumCase<null>;
+        Poison: DB.EnumCase<null>;
+        WorkingSupernaturalCreature: DB.EnumCase<null>;
+    }, []>>>;
+}, []>;
+declare const DefaultEquipmentCategoryTypeRules: DB.TypeAlias<"DefaultEquipmentCategoryTypeRules", DB.Object<{
+    combatValues: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"AllowedCombatValues", DB.Object<{
+        isWeaponAllowed: DB.MemberDecl<DB.Boolean, true>;
+        isArmorAllowed: DB.MemberDecl<DB.Boolean, true>;
+    }>, []>>, true>;
+    restrictedTo: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ValueRule", {
+        Required: DB.EnumCase<null>;
+        Optional: DB.EnumCase<null>;
+        Prohibited: DB.EnumCase<null>;
+    }, []>>, true>;
+    structurePoints: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ValueRule", {
+        Required: DB.EnumCase<null>;
+        Optional: DB.EnumCase<null>;
+        Prohibited: DB.EnumCase<null>;
+    }, []>>, true>;
+    weight: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ValueRule", {
+        Required: DB.EnumCase<null>;
+        Optional: DB.EnumCase<null>;
+        Prohibited: DB.EnumCase<null>;
+    }, []>>, true>;
+    complexity: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ValueRule", {
+        Required: DB.EnumCase<null>;
+        Optional: DB.EnumCase<null>;
+        Prohibited: DB.EnumCase<null>;
+    }, []>>, true>;
+}>, []>;
+export declare const EquipmentCategory: DB.Entity<"EquipmentCategory", {
+    position: DB.MemberDecl<DB.Integer, true>;
+    type: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"EquipmentCategoryType", {
+        Default: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"DefaultEquipmentCategoryTypeRules", DB.Object<{
+            combatValues: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"AllowedCombatValues", DB.Object<{
+                isWeaponAllowed: DB.MemberDecl<DB.Boolean, true>;
+                isArmorAllowed: DB.MemberDecl<DB.Boolean, true>;
+            }>, []>>, true>;
+            restrictedTo: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ValueRule", {
+                Required: DB.EnumCase<null>;
+                Optional: DB.EnumCase<null>;
+                Prohibited: DB.EnumCase<null>;
+            }, []>>, true>;
+            structurePoints: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ValueRule", {
+                Required: DB.EnumCase<null>;
+                Optional: DB.EnumCase<null>;
+                Prohibited: DB.EnumCase<null>;
+            }, []>>, true>;
+            weight: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ValueRule", {
+                Required: DB.EnumCase<null>;
+                Optional: DB.EnumCase<null>;
+                Prohibited: DB.EnumCase<null>;
+            }, []>>, true>;
+            complexity: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ValueRule", {
+                Required: DB.EnumCase<null>;
+                Optional: DB.EnumCase<null>;
+                Prohibited: DB.EnumCase<null>;
+            }, []>>, true>;
+        }>, []>>>;
+        Special: DB.EnumCase<DB.IncludeIdentifier<[], DB.Enum<"SpecialEquipmentCategoryEntity", {
+            AnimalCare: DB.EnumCase<null>;
+            Book: DB.EnumCase<null>;
+            Elixir: DB.EnumCase<null>;
+            GemOrPreciousStone: DB.EnumCase<null>;
+            Newspaper: DB.EnumCase<null>;
+            Poison: DB.EnumCase<null>;
+            WorkingSupernaturalCreature: DB.EnumCase<null>;
+        }, []>>>;
+    }, []>>, true>;
+    translations: DB.MemberDecl<DB.NestedEntityMap<"EquipmentCategoryTranslation", {
+        name: DB.MemberDecl<DB.String, true>;
+    }>, true>;
+}, undefined>;
+export declare const isEquipmentCategoryOfDefaultType: (category: EquipmentCategoryType) => category is Omit<EquipmentCategoryType, "type"> & {
+    type: Case<"Default", DefaultEquipmentCategoryTypeRules>;
+};
+export declare const mergeValueRules: (categories: NonEmptyArray<ValueRule>) => ValueRule["kind"];
+export declare const mergeAllValueRules: (categories: NonEmptyArray<DefaultEquipmentCategoryTypeRules>) => DefaultEquipmentCategoryTypeRules;
+export {};

package/lib/types/equipment/item/EquipmentCategory.js

@@ -0,0 +1,131 @@
+import * as DB from "tsondb/schema/dsl";
+import { NestedTranslationMap } from "../../Locale.js";
+const ValueRule = DB.Enum(import.meta.url, {
+    name: "ValueRule",
+    comment: "Defines if an instance MUST/CAN/MUST NOT define a value for this parameter. If multiple rules apply to the same parameter, the order of precedence is Required > Optional > Prohibited.",
+    values: () => ({
+        Required: DB.EnumCase({
+            comment: "The parameter MUST be present in all instances the rule applies to.",
+            type: null,
+        }),
+        Optional: DB.EnumCase({
+            comment: "The parameter CAN be present in any instances the rule applies to.",
+            type: null,
+        }),
+        Prohibited: DB.EnumCase({
+            comment: "The parameter MUST NOT be present in any instances the rule applies to.",
+            type: null,
+        }),
+    }),
+});
+const AllowedCombatValues = DB.TypeAlias(import.meta.url, {
+    name: "AllowedCombatValues",
+    comment: "The combat values that are allowed for this category. If any combat value is allowed and used, advantages, disadvantages and known item specifics are also allowed to be defined for the item.",
+    type: () => DB.Object({
+        isWeaponAllowed: DB.Required({
+            comment: "Is the item allowed to be used as a weapon?",
+            type: DB.Boolean(),
+        }),
+        isArmorAllowed: DB.Required({
+            comment: "Is the item allowed to be used as an armor?",
+            type: DB.Boolean(),
+        }),
+    }),
+});
+const EquipmentCategoryType = DB.Enum(import.meta.url, {
+    name: "EquipmentCategoryType",
+    values: () => ({
+        Default: DB.EnumCase({
+            comment: "Items that can be expressed using the generic Item entity.",
+            type: DB.IncludeIdentifier(DefaultEquipmentCategoryTypeRules),
+        }),
+        Special: DB.EnumCase({
+            comment: "Items whose rules and/or values cannot be expressed using the generic Item entity.",
+            type: DB.IncludeIdentifier(SpecialEquipmentCategoryEntity),
+        }),
+    }),
+});
+const DefaultEquipmentCategoryTypeRules = DB.TypeAlias(import.meta.url, {
+    name: "DefaultEquipmentCategoryTypeRules",
+    type: () => DB.Object({
+        combatValues: DB.Required({
+            comment: "The combat values that are allowed for this category. If any combat value is allowed and used, advantages, disadvantages and known item specifics are also allowed to be defined for the item.",
+            type: DB.IncludeIdentifier(AllowedCombatValues),
+        }),
+        restrictedTo: DB.Required({
+            comment: "Presence of restrictions to certain groups for items in this category.",
+            type: DB.IncludeIdentifier(ValueRule),
+        }),
+        structurePoints: DB.Required({
+            comment: "Presence of structure points to certain groups for items in this category.",
+            type: DB.IncludeIdentifier(ValueRule),
+        }),
+        weight: DB.Required({
+            comment: "Presence of weight to certain groups for items in this category.",
+            type: DB.IncludeIdentifier(ValueRule),
+        }),
+        complexity: DB.Required({
+            comment: "Presence of complexity to certain groups for items in this category.",
+            type: DB.IncludeIdentifier(ValueRule),
+        }),
+    }),
+});
+const SpecialEquipmentCategoryEntity = DB.Enum(import.meta.url, {
+    name: "SpecialEquipmentCategoryEntity",
+    values: () => ({
+        AnimalCare: DB.EnumCase({ type: null }),
+        Book: DB.EnumCase({ type: null }),
+        Elixir: DB.EnumCase({ type: null }),
+        GemOrPreciousStone: DB.EnumCase({ type: null }),
+        Newspaper: DB.EnumCase({ type: null }),
+        Poison: DB.EnumCase({ type: null }),
+        WorkingSupernaturalCreature: DB.EnumCase({ type: null }),
+    }),
+});
+export const EquipmentCategory = DB.Entity(import.meta.url, {
+    name: "EquipmentCategory",
+    namePlural: "EquipmentCategories",
+    type: () => DB.Object({
+        position: DB.Required({
+            comment: "The position of the category in the list. This has to be a unique value.",
+            type: DB.Integer({ minimum: 0 }),
+        }),
+        type: DB.Required({
+            comment: "The type of the equipment category.",
+            type: DB.IncludeIdentifier(EquipmentCategoryType),
+        }),
+        translations: NestedTranslationMap(DB.Required, "EquipmentCategory", DB.Object({
+            name: DB.Required({
+                comment: "The equipment category’s name.",
+                type: DB.String({ minLength: 1 }),
+            }),
+        })),
+    }),
+    instanceDisplayName: {},
+    sortOrder: { keyPath: "position", isIndex: true },
+    uniqueConstraints: [
+        {
+            keyPath: "position",
+        },
+        {
+            entityMapKeyPath: "translations",
+            keyPathInEntityMap: "name",
+        },
+    ],
+});
+export const isEquipmentCategoryOfDefaultType = (category) => category.type.kind === "Default";
+export const mergeValueRules = (categories) => categories.reduce((acc, elem) => acc === "Required" || elem.kind === "Required"
+    ? "Required"
+    : acc === "Optional" || elem.kind === "Optional"
+        ? "Optional"
+        : "Prohibited", "Prohibited");
+export const mergeAllValueRules = (categories) => ({
+    combatValues: {
+        isWeaponAllowed: categories.some(category => category.combatValues.isWeaponAllowed),
+        isArmorAllowed: categories.some(category => category.combatValues.isArmorAllowed),
+    },
+    restrictedTo: { kind: mergeValueRules(categories.map(category => category.restrictedTo)) },
+    structurePoints: { kind: mergeValueRules(categories.map(category => category.structurePoints)) },
+    weight: { kind: mergeValueRules(categories.map(category => category.weight)) },
+    complexity: { kind: mergeValueRules(categories.map(category => category.complexity)) },
+});

package/lib/types/equipment/item/EquipmentOfBlessedOnes.js

@@ -37,7 +37,7 @@ export const EquipmentOfBlessedOnes = DB.Entity(import.meta.url, {
             return checkWeaponCombatTechniqueIntegrity({
                 ...rest,
                 instanceContent: instanceContent.combat_use.Weapon,
-            }, { secondary: true });
+            });
         }
         return [];
     },

package/lib/types/equipment/item/IlluminationLightSource.js

@@ -45,7 +45,7 @@ export const IlluminationLightSource = DB.Entity(import.meta.url, {
             return checkWeaponCombatTechniqueIntegrity({
                 ...rest,
                 instanceContent: instanceContent.combat_use.Weapon,
-            }, { secondary: true });
+            });
         }
         return [];
     },

package/lib/types/equipment/item/IlluminationRefillOrSupply.js

@@ -41,7 +41,7 @@ export const IlluminationRefillOrSupply = DB.Entity(import.meta.url, {
             return checkWeaponCombatTechniqueIntegrity({
                 ...rest,
                 instanceContent: instanceContent.combat_use.Weapon,
-            }, { secondary: true });
+            });
         }
         return [];
     },