optolith-database-schema 0.31.3 → 0.32.0

package/lib/types/magicalActions/MagicalDance.js

@@ -1,10 +1,11 @@
 import * as DB from "tsondb/schema/dsl";
 import { OldParameter } from "../_ActivatableSkill.js";
 import { CheckResultBasedModifier } from "../_ActivatableSkillCheckResultBased.js";
+import { NonModifiableOneTimeCostPerCountable } from "../_ActivatableSkillCost.js";
 import { ActivatableSkillEffect } from "../_ActivatableSkillEffect.js";
 import { ArcaneDancerTraditionIdentifier, PropertyIdentifier } from "../_Identifier.js";
 import { ImprovementCost } from "../_ImprovementCost.js";
-import { ResponsiveText, ResponsiveTextOptional } from "../_ResponsiveText.js";
+import { ResponsiveText } from "../_ResponsiveText.js";
 import { SkillCheck } from "../_SkillCheck.js";
 import { NestedTranslationMap } from "../Locale.js";
 import { Errata } from "../source/_Erratum.js";
@@ -95,18 +96,16 @@ const FixedMagicalDanceCost = DB.TypeAlias(import.meta.url, {
             comment: "The (temporary) AE cost value.",
             type: DB.Integer({ minimum: 1 }),
         }),
-        translations: NestedTranslationMap(DB.Optional, "FixedMagicalDanceCost", DB.Object({
-            per: DB.Optional({
-                comment: "The cost have to be per a specific countable entity, e.g. `8 KP per person`.",
-                type: DB.IncludeIdentifier(ResponsiveTextOptional),
-            }),
-        }, { minProperties: 1 })),
+        per: DB.Optional({
+            comment: "The cost have to be per a specific countable entity, e.g. `8 KP per person`.",
+            type: DB.IncludeIdentifier(NonModifiableOneTimeCostPerCountable),
+        }),
     }),
 });
 const IndefiniteMagicalDanceCost = DB.TypeAlias(import.meta.url, {
     name: "IndefiniteMagicalDanceCost",
     type: () => DB.Object({
-        maximum: DB.Optional({
+        modifier: DB.Optional({
             comment: "Specified if the indefinite description's result value is to be modified by a certain number.",
             type: DB.IncludeIdentifier(CheckResultBasedModifier),
         }),

package/lib/types/magicalActions/MagicalRune.d.ts

@@ -2,28 +2,15 @@ import * as DB from "tsondb/schema/dsl";
 export declare const MagicalRune: DB.Entity<"MagicalRune", {
     options: DB.MemberDecl<DB.ChildEntities<DB.Entity<"MagicalRuneOption", {
         parent: DB.MemberDecl<DB.ReferenceIdentifier, true>;
-        cost: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"MagicalRuneOptionCost", {
-            Single: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"SingleMagicalRuneCost", DB.Object<{
-                value: DB.MemberDecl<DB.Integer, true>;
-                translations: DB.MemberDecl<DB.NestedEntityMap<"SingleMagicalRuneCostTranslation", {
-                    note: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
-                        full: DB.MemberDecl<DB.String, true>;
-                        compressed: DB.MemberDecl<DB.String, false>;
-                    }>, []>>, true>;
-                }>, false>;
-            }>, []>>>;
-            Disjunction: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"MagicalRuneCostDisjunction", DB.Object<{
-                list: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"SingleMagicalRuneCost", DB.Object<{
-                    value: DB.MemberDecl<DB.Integer, true>;
-                    translations: DB.MemberDecl<DB.NestedEntityMap<"SingleMagicalRuneCostTranslation", {
-                        note: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
-                            full: DB.MemberDecl<DB.String, true>;
-                            compressed: DB.MemberDecl<DB.String, false>;
-                        }>, []>>, true>;
-                    }>, false>;
-                }>, []>>>, true>;
-            }>, []>>>;
-        }, []>>, false>;
+        cost: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"SingleMagicalRuneCost", DB.Object<{
+            value: DB.MemberDecl<DB.Integer, true>;
+            translations: DB.MemberDecl<DB.NestedEntityMap<"SingleMagicalRuneCostTranslation", {
+                note: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
+                    full: DB.MemberDecl<DB.String, true>;
+                    compressed: DB.MemberDecl<DB.String, false>;
+                }>, []>>, true>;
+            }>, false>;
+        }>, []>>, false>;
         improvement_cost: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ImprovementCost", {
             A: DB.EnumCase<null>;
             B: DB.EnumCase<null>;
@@ -83,12 +70,14 @@ export declare const MagicalRune: DB.Entity<"MagicalRune", {
         }, []>>, true>;
         crafting_time: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"MagicalRuneCraftingTime", DB.Object<{
             value: DB.MemberDecl<DB.Integer, true>;
-            translations: DB.MemberDecl<DB.NestedEntityMap<"MagicalRuneCraftingTimeTranslation", {
-                per: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveText", DB.Object<{
-                    full: DB.MemberDecl<DB.String, true>;
-                    compressed: DB.MemberDecl<DB.String, true>;
-                }>, []>>, true>;
-            }>, false>;
+            per: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"MagicalRuneCraftingTimePerCountable", DB.Object<{
+                translations: DB.MemberDecl<DB.NestedEntityMap<"MagicalRuneCraftingTimePerCountableTranslation", {
+                    countable: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveText", DB.Object<{
+                        full: DB.MemberDecl<DB.String, true>;
+                        compressed: DB.MemberDecl<DB.String, true>;
+                    }>, []>>, true>;
+                }>, true>;
+            }>, []>>, false>;
         }>, []>>, true>;
         duration: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"MagicalRuneDuration", DB.Object<{
             slow: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"CheckResultBasedDuration", DB.Object<{
@@ -259,28 +248,15 @@ export declare const MagicalRune: DB.Entity<"MagicalRune", {
 }, undefined>;
 export declare const MagicalRuneOption: DB.Entity<"MagicalRuneOption", {
     parent: DB.MemberDecl<DB.ReferenceIdentifier, true>;
-    cost: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"MagicalRuneOptionCost", {
-        Single: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"SingleMagicalRuneCost", DB.Object<{
-            value: DB.MemberDecl<DB.Integer, true>;
-            translations: DB.MemberDecl<DB.NestedEntityMap<"SingleMagicalRuneCostTranslation", {
-                note: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
-                    full: DB.MemberDecl<DB.String, true>;
-                    compressed: DB.MemberDecl<DB.String, false>;
-                }>, []>>, true>;
-            }>, false>;
-        }>, []>>>;
-        Disjunction: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"MagicalRuneCostDisjunction", DB.Object<{
-            list: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"SingleMagicalRuneCost", DB.Object<{
-                value: DB.MemberDecl<DB.Integer, true>;
-                translations: DB.MemberDecl<DB.NestedEntityMap<"SingleMagicalRuneCostTranslation", {
-                    note: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
-                        full: DB.MemberDecl<DB.String, true>;
-                        compressed: DB.MemberDecl<DB.String, false>;
-                    }>, []>>, true>;
-                }>, false>;
-            }>, []>>>, true>;
-        }>, []>>>;
-    }, []>>, false>;
+    cost: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"SingleMagicalRuneCost", DB.Object<{
+        value: DB.MemberDecl<DB.Integer, true>;
+        translations: DB.MemberDecl<DB.NestedEntityMap<"SingleMagicalRuneCostTranslation", {
+            note: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
+                full: DB.MemberDecl<DB.String, true>;
+                compressed: DB.MemberDecl<DB.String, false>;
+            }>, []>>, true>;
+        }>, false>;
+    }>, []>>, false>;
     improvement_cost: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ImprovementCost", {
         A: DB.EnumCase<null>;
         B: DB.EnumCase<null>;

package/lib/types/magicalActions/MagicalRune.js

@@ -164,13 +164,6 @@ const MagicalRuneCost = DB.Enum(import.meta.url, {
         DerivedFromOption: DB.EnumCase({ type: null }),
     }),
 });
-const MagicalRuneOptionCost = DB.Enum(import.meta.url, {
-    name: "MagicalRuneOptionCost",
-    values: () => ({
-        Single: DB.EnumCase({ type: DB.IncludeIdentifier(SingleMagicalRuneCost) }),
-        Disjunction: DB.EnumCase({ type: DB.IncludeIdentifier(MagicalRuneCostDisjunction) }),
-    }),
-});
 const SingleMagicalRuneCost = DB.TypeAlias(import.meta.url, {
     name: "SingleMagicalRuneCost",
     type: () => DB.Object({
@@ -198,6 +191,17 @@ const MagicalRuneCostDisjunction = DB.TypeAlias(import.meta.url, {
         }),
     }),
 });
+const MagicalRuneCraftingTimePerCountable = DB.TypeAlias(import.meta.url, {
+    name: "MagicalRuneCraftingTimePerCountable",
+    type: () => DB.Object({
+        translations: NestedTranslationMap(DB.Required, "MagicalRuneCraftingTimePerCountable", DB.Object({
+            countable: DB.Required({
+                comment: "The countable entity name.",
+                type: DB.IncludeIdentifier(ResponsiveText),
+            }),
+        })),
+    }),
+});
 const MagicalRuneCraftingTime = DB.TypeAlias(import.meta.url, {
     name: "MagicalRuneCraftingTime",
     type: () => DB.Object({
@@ -205,12 +209,10 @@ const MagicalRuneCraftingTime = DB.TypeAlias(import.meta.url, {
             comment: "The crafting time in actions.",
             type: DB.Integer({ minimum: 1 }),
         }),
-        translations: NestedTranslationMap(DB.Optional, "MagicalRuneCraftingTime", DB.Object({
-            per: DB.Required({
-                comment: "The crafting time has to be per a specific countable entity, e.g. `8 actions per person`.",
-                type: DB.IncludeIdentifier(ResponsiveText),
-            }),
-        })),
+        per: DB.Optional({
+            comment: "The crafting time has to be per a specific countable entity, e.g. `8 Actions per person`.",
+            type: DB.IncludeIdentifier(MagicalRuneCraftingTimePerCountable),
+        }),
     }),
 });
 const MagicalRuneDuration = DB.TypeAlias(import.meta.url, {
@@ -243,7 +245,7 @@ export const MagicalRuneOption = DB.Entity(import.meta.url, {
         }),
         cost: DB.Optional({
             comment: "The option-specific AE cost.",
-            type: DB.IncludeIdentifier(MagicalRuneOptionCost),
+            type: DB.IncludeIdentifier(SingleMagicalRuneCost),
         }),
         improvement_cost: DB.Optional({
             comment: "The option-specific improvement cost.",

package/lib/types/magicalActions/ZibiljaRitual.d.ts

@@ -35,7 +35,7 @@ export declare const ZibiljaRitual: DB.Entity<"ZibiljaRitual", {
                                 full: DB.MemberDecl<DB.String, true>;
                                 compressed: DB.MemberDecl<DB.String, true>;
                             }>, []>>, true>;
-                        }>, false>;
+                        }>, true>;
                     }>, []>>, false>;
                     translations: DB.MemberDecl<DB.NestedEntityMap<"NonModifiableOneTimeCostTranslation", {
                         note: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
@@ -75,7 +75,7 @@ export declare const ZibiljaRitual: DB.Entity<"ZibiljaRitual", {
                                 full: DB.MemberDecl<DB.String, true>;
                                 compressed: DB.MemberDecl<DB.String, true>;
                             }>, []>>, true>;
-                        }>, false>;
+                        }>, true>;
                     }>, []>>, false>;
                     translations: DB.MemberDecl<DB.NestedEntityMap<"NonModifiableOneTimeCostTranslation", {
                         note: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
@@ -115,7 +115,7 @@ export declare const ZibiljaRitual: DB.Entity<"ZibiljaRitual", {
                                 full: DB.MemberDecl<DB.String, true>;
                                 compressed: DB.MemberDecl<DB.String, true>;
                             }>, []>>, true>;
-                        }>, false>;
+                        }>, true>;
                     }>, []>>, false>;
                     translations: DB.MemberDecl<DB.NestedEntityMap<"NonModifiableOneTimeCostTranslation", {
                         note: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{

package/lib/types/prerequisites/PrerequisiteGroups.d.ts

@@ -800,7 +800,6 @@ export declare const ProfessionPrerequisiteGroup: DB.Enum<"ProfessionPrerequisit
     }>, []>>>;
 }, []>;
 export declare const AdvantageDisadvantagePrerequisiteGroup: DB.Enum<"AdvantageDisadvantagePrerequisiteGroup", {
-    CommonSuggestedByRCP: DB.EnumCase<null>;
     Sex: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"SexPrerequisite", DB.Object<{
         id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"BinarySex", {
             Male: DB.EnumCase<null>;
@@ -1176,13 +1175,14 @@ export declare const AdvantageDisadvantagePrerequisiteGroup: DB.Enum<"AdvantageD
             text: DB.MemberDecl<DB.String, true>;
         }>, true>;
     }>, []>>>;
-    NoOtherAncestorBloodAdvantage: DB.EnumCase<null>;
     SexualCharacteristic: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"SexualCharacteristicPrerequisite", DB.Object<{
         id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SexualCharacteristic", {
             Penis: DB.EnumCase<null>;
             Vagina: DB.EnumCase<null>;
         }, []>>, true>;
     }>, []>>>;
+    CommonSuggestedByRCP: DB.EnumCase<null>;
+    NoOtherAncestorBloodAdvantage: DB.EnumCase<null>;
 }, []>;
 export declare const ArcaneTraditionPrerequisiteGroup: DB.Enum<"ArcaneTraditionPrerequisiteGroup", {
     Sex: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"SexPrerequisite", DB.Object<{

package/lib/types/prerequisites/PrerequisiteGroups.js

@@ -86,30 +86,10 @@ export const AdvantageDisadvantagePrerequisiteGroup = DB.Enum(import.meta.url, {
     values: () => {
         return {
             CommonSuggestedByRCP: DB.EnumCase({ type: null }),
-            Sex: DB.EnumCase({ type: DB.IncludeIdentifier(SexPrerequisite) }),
-            Race: DB.EnumCase({ type: DB.IncludeIdentifier(RacePrerequisite) }),
-            Culture: DB.EnumCase({ type: DB.IncludeIdentifier(CulturePrerequisite) }),
-            Pact: DB.EnumCase({ type: DB.IncludeIdentifier(PactPrerequisite) }),
-            SocialStatus: DB.EnumCase({ type: DB.IncludeIdentifier(SocialStatusPrerequisite) }),
-            State: DB.EnumCase({ type: DB.IncludeIdentifier(StatePrerequisite) }),
-            Rule: DB.EnumCase({ type: DB.IncludeIdentifier(RulePrerequisite) }),
-            PrimaryAttribute: DB.EnumCase({ type: DB.IncludeIdentifier(PrimaryAttributePrerequisite) }),
-            Activatable: DB.EnumCase({ type: DB.IncludeIdentifier(ActivatablePrerequisite) }),
-            BlessedTradition: DB.EnumCase({ type: DB.IncludeIdentifier(BlessedTraditionPrerequisite) }),
-            MagicalTradition: DB.EnumCase({ type: DB.IncludeIdentifier(MagicalTraditionPrerequisite) }),
-            Rated: DB.EnumCase({ type: DB.IncludeIdentifier(RatedPrerequisite) }),
-            RatedMinimumNumber: DB.EnumCase({
-                type: DB.IncludeIdentifier(RatedMinimumNumberPrerequisite),
-            }),
-            RatedSum: DB.EnumCase({ type: DB.IncludeIdentifier(RatedSumPrerequisite) }),
-            Enhancement: DB.EnumCase({ type: DB.IncludeIdentifier(EnhancementPrerequisite) }),
-            Text: DB.EnumCase({ type: DB.IncludeIdentifier(TextPrerequisite) }),
             NoOtherAncestorBloodAdvantage: DB.EnumCase({
                 type: AncestorBloodPrerequisite,
             }),
-            SexualCharacteristic: DB.EnumCase({
-                type: DB.IncludeIdentifier(SexualCharacteristicPrerequisite),
-            }),
+            ...GeneralPrerequisiteGroup.type.value.values,
         };
     },
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "optolith-database-schema",
-  "version": "0.31.3",
+  "version": "0.32.0",
   "description": "Definitions and utilities for the flat-file database of Optolith, a character creation tool for the Pen and Paper RPG “The Dark Eye 5”, and its external integrations into other software.",
   "keywords": [
     "tde",
@@ -38,20 +38,20 @@
   "author": "Lukas Obermann",
   "license": "MPL-2.0",
   "dependencies": {
-    "@elyukai/utils": "^0.2.2",
+    "@elyukai/utils": "^0.2.4",
     "tsondb": "^0.19.9",
     "yaml": "^2.8.2"
   },
   "devDependencies": {
-    "@eslint/js": "^9.39.2",
-    "@types/node": "^25.2.1",
+    "@eslint/js": "^10.0.1",
+    "@types/node": "^25.3.0",
     "commit-and-tag-version": "^12.6.1",
-    "eslint": "^9.39.2",
+    "eslint": "^10.0.1",
     "globals": "^17.3.0",
-    "nodemon": "^3.1.11",
+    "nodemon": "^3.1.14",
     "prettier": "^3.8.1",
     "typescript": "^5.9.3",
-    "typescript-eslint": "^8.54.0"
+    "typescript-eslint": "^8.56.0"
   },
   "repository": "github:elyukai/optolith-database-schema",
   "bugs": {