@optolith/entity-descriptions 0.4.3 → 0.4.5

package/CHANGELOG.md

@@ -2,6 +2,23 @@
 
 All notable changes to this project will be documented in this file. See [commit-and-tag-version](https://github.com/absolute-version/commit-and-tag-version) for commit guidelines.
 
+## [0.4.5](https://github.com/Optolith/entity-descriptions/compare/v0.4.4...v0.4.5) (2026-03-14)
+
+
+### Bug Fixes
+
+* do not display the twelve blessings for shamanistic professions ([e95cc0d](https://github.com/Optolith/entity-descriptions/commit/e95cc0df5312dfcd6fd8ae571e728eccf08601e2))
+* join prerequisites of the same entry more reliably ([c317c62](https://github.com/Optolith/entity-descriptions/commit/c317c629a5f091cc23485717fad795538aabf0c2))
+* rendering of blessings in packages and variants ([d04e247](https://github.com/Optolith/entity-descriptions/commit/d04e24761204303211157e1154446bc8f1828c43))
+
+## [0.4.4](https://github.com/Optolith/entity-descriptions/compare/v0.4.3...v0.4.4) (2026-03-14)
+
+
+### Bug Fixes
+
+* book display ([dfc07ee](https://github.com/Optolith/entity-descriptions/commit/dfc07eed999c02890a3516aaacd64313c226c9cb))
+* working creature optional value guards ([11a283a](https://github.com/Optolith/entity-descriptions/commit/11a283af9082b64eb48823cb90107394fa8baa5b))
+
 ## [0.4.3](https://github.com/Optolith/entity-descriptions/compare/v0.4.2...v0.4.3) (2026-03-14)
 
 

package/lib/entities/equipment.d.ts

@@ -19,6 +19,6 @@ export declare const renderRangedWeapon: <Damage>(translate: Translate, translat
  * Get a JSON representation of the rules text for equipment.
  */
 export declare const getEquipmentEntityDescription: import("../creator.js").EntityDescriptionCreator<"Weapon" | "Armor" | "Ammunition" | "Animal" | "AnimalCare" | "BandageOrRemedy" | "Book" | "CeremonialItem" | "Clothes" | "ClothingPackage" | "Container" | "EquipmentOfBlessedOnes" | "GemOrPreciousStone" | "IlluminationLightSource" | "IlluminationRefillOrSupply" | "Jewelry" | "Laboratory" | "Liebesspielzeug" | "LuxuryGood" | "MagicalArtifact" | "MusicalInstrument" | "Newspaper" | "OrienteeringAid" | "RopeOrChain" | "Stationery" | "ThievesTool" | "ToolOfTheTrade" | "TravelGearOrTool" | "Vehicle" | "WeaponAccessory" | "WorkingSupernaturalCreature", {
-    getInstanceById: GetInstanceById<"Publication" | "Attribute" | "Reach" | "SocialStatus" | "CloseCombatTechnique" | "RangedCombatTechnique" | "MagicalTradition" | "BlessedTradition" | "DerivedCharacteristic" | "Ammunition" | "Race" | "Culture" | "Profession">;
+    getInstanceById: GetInstanceById<"Publication" | "Attribute" | "Reach" | "SocialStatus" | "CloseCombatTechnique" | "RangedCombatTechnique" | "MagicalTradition" | "BlessedTradition" | "DerivedCharacteristic" | "Ammunition" | "Race" | "Culture" | "Profession" | "Skill">;
     idMap: IdMap;
 }, import("../index.js").EntityDescription>;

package/lib/entities/equipment.js

@@ -1,5 +1,6 @@
 import { ensureNonEmpty, isNotEmpty } from "@elyukai/utils/array/nonEmpty";
 import { isNotNullish } from "@elyukai/utils/nullable";
+import { romanize } from "@elyukai/utils/roman";
 import { sign } from "@elyukai/utils/string/number";
 import { assertExhaustive } from "@elyukai/utils/typeSafety";
 import { mapNullable } from "@optolith/helpers/nullable";
@@ -22,12 +23,13 @@ export const getEquipmentName = (translate, translateMap, getInstanceById, entry
                 socialStatus: socialStatusName,
             });
         }
+        case "Book":
+            return translateMap(entry.content.translations)?.name ?? MISSING_VALUE;
         case "Ammunition":
         case "Animal":
         case "AnimalCare":
         case "Armor":
         case "BandageOrRemedy":
-        case "Book":
         case "CeremonialItem":
         case "Clothes":
         case "Container":
@@ -433,7 +435,6 @@ const normalizeCombatValues = (entity) => {
         case "Animal":
         case "AnimalCare":
         case "BandageOrRemedy":
-        case "Book":
         case "CeremonialItem":
         case "Clothes":
         case "ClothingPackage":
@@ -481,11 +482,223 @@ const normalizeCombatValues = (entity) => {
             return assertExhaustive(entity);
     }
 };
+const renderBookTypes = (translate, translateMap, localeJoin, localeCompare, getInstanceById, types) => types
+    .map((type) => {
+    switch (type.kind) {
+        case "Mundane":
+            switch (type.Mundane.kind) {
+                case "RomanceNovel":
+                    return [translate("Romance Novel")];
+                case "Poetry":
+                    return [translate("Poetry")];
+                case "PoliticalPamphlet":
+                    return [translate("Political Pamphlet")];
+                case "CrimeStory":
+                    return [translate("Crime Story")];
+                case "FairyTale":
+                    return [translate("Fairy Tale")];
+                case "Novel":
+                    return [translate("Novel")];
+                case "ProfessionalPublication":
+                    return [
+                        translate("Professional Publication"),
+                        translateMap(getInstanceById("Skill", type.Mundane.ProfessionalPublication)?.translations)?.name ?? MISSING_VALUE,
+                    ];
+                default:
+                    return assertExhaustive(type.Mundane);
+            }
+        case "Magical":
+            return [translate("Magical Book")];
+        case "Religious":
+            return [translate("Religious Works")];
+        default:
+            return assertExhaustive(type);
+    }
+})
+    .reduce((accTypes, [main, sub]) => {
+    const last = accTypes.at(-1);
+    return last?.[1] === undefined || sub === undefined
+        ? [...accTypes, [main, sub === undefined ? undefined : [sub]]]
+        : [...accTypes.slice(0, -1), [last[0], [...last[1], sub]]];
+}, [])
+    .map(([main, sub]) => sub === undefined
+    ? main
+    : `${main} (${localeJoin(sub.toSorted(localeCompare), "conjunction")})`)
+    .join(", ");
+const renderBookRules = (translate, rules) => {
+    switch (rules.kind) {
+        case "Plain":
+            if (rules.Plain.reconstruction === undefined &&
+                rules.Plain.references === undefined &&
+                rules.Plain.textAfter === undefined) {
+                return rules.Plain.text;
+            }
+            return [
+                {
+                    type: "plain",
+                    text: rules.Plain.text,
+                },
+                {
+                    type: "definitionList",
+                    style: "nested",
+                    items: [
+                        mapNullable(rules.Plain.reconstruction, reconstruction => ({
+                            label: translate("Reconstruction"),
+                            value: reconstruction,
+                        })),
+                        mapNullable(rules.Plain.references, references => ({
+                            label: translate("References"),
+                            value: references,
+                        })),
+                    ],
+                },
+                mapNullable(rules.Plain.textAfter, textAfter => ({
+                    type: "plain",
+                    text: textAfter,
+                })),
+            ];
+        case "Entertainment":
+            return translate("Entertainment");
+        case "ByEdition":
+            return [
+                {
+                    type: "definitionList",
+                    style: "nested",
+                    items: [
+                        ...rules.ByEdition.editions.map((edition) => {
+                            if (edition.reconstruction === undefined && edition.references === undefined) {
+                                return {
+                                    label: edition.label,
+                                    value: edition.text,
+                                };
+                            }
+                            return {
+                                label: edition.label,
+                                value: [
+                                    {
+                                        type: "plain",
+                                        text: edition.text,
+                                    },
+                                    {
+                                        type: "definitionList",
+                                        style: "nested",
+                                        items: [
+                                            mapNullable(edition.reconstruction, reconstruction => ({
+                                                label: translate("Reconstruction"),
+                                                value: reconstruction,
+                                            })),
+                                            mapNullable(edition.references, references => ({
+                                                label: translate("References"),
+                                                value: references,
+                                            })),
+                                        ],
+                                    },
+                                ],
+                            };
+                        }),
+                    ],
+                },
+                mapNullable(rules.ByEdition.textAfter, textAfter => ({
+                    type: "plain",
+                    text: textAfter,
+                })),
+            ];
+        default:
+            return assertExhaustive(rules);
+    }
+};
 /**
  * Get a JSON representation of the rules text for equipment.
  */
 export const getEquipmentEntityDescription = createEntityDescriptionCreator(({ getInstanceById, idMap }, locale, entry) => {
     const { translate, translateMap } = locale;
+    if (entry.entity === "Book") {
+        const translation = translateMap(entry.content.translations);
+        if (translation === undefined) {
+            return undefined;
+        }
+        const name = getEquipmentName(translate, translateMap, getInstanceById, entry);
+        return {
+            title: name,
+            className: "equipment",
+            body: [
+                {
+                    type: "definitionList",
+                    items: [
+                        {
+                            label: translate("Name"),
+                            value: name,
+                        },
+                        {
+                            label: translate("Type"),
+                            value: renderBookTypes(translate, translateMap, locale.join, locale.compare, getInstanceById, entry.content.types),
+                        },
+                        translation.language !== undefined || translation.script !== undefined
+                            ? {
+                                label: translate("Language/Script"),
+                                value: [translation.language, translation.script]
+                                    .map(value => value ?? "—")
+                                    .join(" / "),
+                            }
+                            : undefined,
+                        entry.content.contentQuality === undefined
+                            ? undefined
+                            : {
+                                label: translate("Content Quality"),
+                                value: (() => {
+                                    switch (entry.content.contentQuality.kind) {
+                                        case "Modest":
+                                            return translate("Modest");
+                                        case "Average":
+                                            return translate("Average");
+                                        case "Demanding":
+                                            return (translate("Demanding") +
+                                                parensIf(translate("CL {$level}", {
+                                                    level: romanize(entry.content.contentQuality.Demanding),
+                                                })));
+                                        default:
+                                            return assertExhaustive(entry.content.contentQuality);
+                                    }
+                                })(),
+                            },
+                        mapNullable(entry.content.cost, cost => renderCost(translate, translateMap, locale.formatNumber, cost)),
+                        translation.note === undefined
+                            ? undefined
+                            : {
+                                label: translate("Note"),
+                                value: translation.note,
+                            },
+                        translation.rules === undefined
+                            ? undefined
+                            : {
+                                label: translate("Rules"),
+                                value: renderBookRules(translate, translation.rules),
+                            },
+                        translation.legality === undefined
+                            ? undefined
+                            : {
+                                label: translate("Legality"),
+                                value: translation.legality,
+                            },
+                        translation.availability === undefined
+                            ? undefined
+                            : {
+                                label: translate("Availability"),
+                                value: translation.availability,
+                            },
+                        translation.special === undefined
+                            ? undefined
+                            : {
+                                label: translate("Special"),
+                                value: translation.special,
+                            },
+                    ],
+                },
+            ],
+            errata: translation.errata,
+            references: entry.content.src,
+        };
+    }
     const translation = entry.entity === "ClothingPackage" ? undefined : translateMap(entry.content.translations);
     if (entry.entity !== "ClothingPackage" && translation === undefined) {
         return undefined;
@@ -522,14 +735,6 @@ export const getEquipmentEntityDescription = createEntityDescriptionCreator(({ g
                         label: translate("Color"),
                         value: color,
                     })),
-                    baseItemTranslation?.language !== undefined || baseItemTranslation?.script !== undefined
-                        ? {
-                            label: translate("Language/Script"),
-                            value: [baseItemTranslation.language, baseItemTranslation.script]
-                                .map(value => value ?? "—")
-                                .join(" / "),
-                        }
-                        : undefined,
                     baseItem.structure_points !== undefined && isNotEmpty(baseItem.structure_points)
                         ? {
                             label: translate("Structure Points"),
@@ -584,13 +789,13 @@ export const getEquipmentEntityDescription = createEntityDescriptionCreator(({ g
                             value: baseItemTranslation.appearance,
                         }
                         : undefined,
-                    baseItemTranslation?.appearance !== undefined
+                    baseItemTranslation?.components !== undefined
                         ? {
                             label: translate("Components"),
                             value: baseItemTranslation.components,
                         }
                         : undefined,
-                    baseItemTranslation?.appearance !== undefined
+                    baseItemTranslation?.use !== undefined
                         ? {
                             label: translate("Use"),
                             value: baseItemTranslation.use,

package/lib/entities/partial/activatableNameChunks.js

@@ -57,13 +57,10 @@ const normalizeChunks = (chunk) => (Array.isArray(chunk) ? combinePair(chunk) :
  */
 const zipChunks = (chunks) => chunks
     .map(normalizeChunks)
-    .reduce((acc, chunk) => acc === "" ? chunk : combineChunks(acc, chunk, (a, b) => `${a}, ${b}`), "");
+    .reduce((acc, chunk) => (acc === "" ? chunk : combineChunks(acc, chunk, (a, b) => `${a}, ${b}`)), "");
 const renderLevel = (formatAsPrerequisite, id, level) => level === undefined
     ? undefined
-    : formatAsPrerequisite ||
-        id.kind === "Advantage" ||
-        id.kind === "Disadvantage" ||
-        level === 1
+    : formatAsPrerequisite || id.kind === "Advantage" || id.kind === "Disadvantage" || level === 1
         ? romanize(level)
         : `I–${romanize(level)}`;
 /**
@@ -86,9 +83,7 @@ const renderActivatableNameChunk = (translateMap, chunk) => {
  */
 export const renderActivatableNameComponentsWithoutLevel = (translateMap, components) => {
     const { levelPlacement, useParenthesis } = components.nameBuilderRules;
-    const wrapParens = useParenthesis
-        ? str => `(${str})`
-        : identity;
+    const wrapParens = useParenthesis ? str => `(${str})` : identity;
     const base = renderActivatableNameChunk(translateMap, components.base);
     const options = components.options === undefined
         ? undefined
@@ -313,13 +308,10 @@ export const renderActivatableNameComponentsCombinedIfPossible = (translateMap,
 // }
 const renderOptions = (displayedInProfession, getResolvedSelectOptionById, id, options) => {
     const arr = options?.map(optionId => {
-        const optTranslations = getResolvedSelectOptionById(id, optionId)?.content
-            .translations;
+        const optTranslations = getResolvedSelectOptionById(id, optionId)?.content.translations;
         return optTranslations === undefined
             ? MISSING_VALUE
-            : mapObject(optTranslations, t10n => displayedInProfession
-                ? (t10n.name_in_profession ?? t10n.name)
-                : t10n.name);
+            : mapObject(optTranslations, t10n => displayedInProfession ? (t10n.name_in_profession ?? t10n.name) : t10n.name);
     }) ?? [];
     if (isNotEmpty(arr) && arr.length > 1) {
         const [first, ...rest] = arr;

package/lib/entities/partial/prerequisites/part.js

@@ -3,6 +3,7 @@ import { deepEqual, equal } from "@elyukai/utils/equality";
 import { on } from "@elyukai/utils/function";
 import { compareNumber, reduceCompare } from "@elyukai/utils/ordering";
 import { assertExhaustive } from "@optolith/helpers/typeSafety";
+import { fromUniformCase } from "tsondb/schema/gen";
 import { renderActivatableNameComponents, renderActivatableNameComponentsCombinedIfPossible, } from "../activatableNameChunks.js";
 /**
  * Type guard for prerequisite parts with a value object.
@@ -53,6 +54,7 @@ const appendPrerequisitePartGroup = (previous, translateMap, localeCompare, part
     }
     else if (parts.every(hasPartValueObject)) {
         return appendBySentenceType(previous, parts
+            .toSorted(on(part => fromUniformCase(part.value.id), localeCompare))
             .reduce((acc, current, i, arr) => {
             if (acc[1] > 0) {
                 return [acc[0], acc[1] - 1];

package/lib/entities/profession.js

@@ -368,22 +368,28 @@ const renderRestrictedBlessings = (restrictedBlessings) => {
             return assertExhaustive(restrictedBlessings);
     }
 };
-const renderSingleBlessings = (traditions) => Reader.traverse(traditions, traditionId => getInstanceByIdR("BlessedTradition", traditionId).map(tradition => tradition?.restricted_blessings)).thenW(restrictedBlessingsList => !isNotEmpty(restrictedBlessingsList)
+const renderSingleBlessings = (traditions) => Reader.traverse(traditions, traditionId => getInstanceByIdR("BlessedTradition", traditionId).map(tradition => tradition
+    ? { restrictedBlessings: tradition.restricted_blessings, type: tradition.type }
+    : undefined)).thenW(restrictedBlessingsList => !isNotEmpty(restrictedBlessingsList)
     ? Reader.of(undefined)
     : restrictedBlessingsList.length === 1
         ? (() => {
-            const [restrictedBlessings] = restrictedBlessingsList;
-            return restrictedBlessings === undefined
-                ? translateR("The Twelve Blessings")
-                : translateR("The Twelve Blessings").thenW(base => renderRestrictedBlessings(restrictedBlessings).thenW(list => translateR("except for {$list :list type=conjunction}", {
-                    list,
-                }).map(note => base + parensIf(note))));
+            const [first] = restrictedBlessingsList;
+            const { restrictedBlessings, type } = first ?? {};
+            return type?.kind === "Shamanistic"
+                ? Reader.of(undefined)
+                : restrictedBlessings === undefined
+                    ? translateR("The Twelve Blessings")
+                    : translateR("The Twelve Blessings").thenW(base => renderRestrictedBlessings(restrictedBlessings).thenW(list => translateR("except for {$list :list type=conjunction}", {
+                        list,
+                    }).map(note => base + parensIf(note))));
         })()
-        : restrictedBlessingsList.some(isNotNullish)
-            ? translateR("The Twelve Blessings").map2(translateR("depends on selected tradition"), (base, note) => base + parensIf(note))
-            : translateR("The Twelve Blessings"));
-const renderBlessings = (professionPackages) => {
-    const traditions = professionPackages.map(pkg => retrieveBlessedTraditionIdentifierFromPrerequisites(pkg.content.prerequisites));
+        : restrictedBlessingsList.every(trad => trad?.type.kind === "Shamanistic")
+            ? Reader.of(undefined)
+            : restrictedBlessingsList.some(trad => trad?.restrictedBlessings !== undefined || trad?.type.kind === "Shamanistic")
+                ? translateR("The Twelve Blessings").map2(translateR("depends on selected tradition"), (base, note) => base + parensIf(note))
+                : translateR("The Twelve Blessings"));
+const renderBlessings = (traditions) => {
     if (traditions.every(isEmpty)) {
         return Reader.of(undefined);
     }
@@ -395,13 +401,21 @@ const renderBlessings = (professionPackages) => {
         return Reader.traverse(traditions, option => option.length === 0 ? Reader.of("—") : renderSingleBlessings(option)).map(list => list.join(" / "));
     }
 };
+const renderBlessingsForPackages = (professionPackages) => renderBlessings(professionPackages.map(pkg => retrieveBlessedTraditionIdentifierFromPrerequisites(pkg.content.prerequisites)));
+const renderBlessingsForVariant = (professionVariant) => renderBlessings([
+    retrieveBlessedTraditionIdentifierFromPrerequisites(professionVariant.prerequisites),
+]).map(blessingsText => (blessingsText !== undefined ? [blessingsText] : []));
 const renderLiturgicalChantName = (liturgyIds) => Reader.traverse(liturgyIds, strictNameR).thenW(list => localeJoinR(list, "disjunction"));
 const renderLiturgicalChants = (professionPackages) => Reader.sequence([
-    renderBlessings(professionPackages),
+    renderBlessingsForPackages(professionPackages),
     renderNumericListAcrossPackages(professionPackages, (pkg) => Reader.of(pkg.content.liturgical_chants?.map(ct => [ct.id, ct.rating_modifier]) ?? []), deepEqual, renderLiturgicalChantName, 0),
     renderLiturgiesOption(professionPackages),
 ]).map(list => ensureNonEmpty(list.filter(isNotNullish))?.join(", "));
+const baseHasNoTradition = (base) => isEmpty(retrieveBlessedTraditionIdentifierFromPrerequisites(base.prerequisites));
 const renderRatedVariantChanges = (baseList, variantList, renderInstance) => Reader.traverse(variantList ?? [], ({ id, rating_modifier }) => {
+    if (baseList === "ignore") {
+        return renderInstance(id).map(name => `${name} ${rating_modifier.toFixed()}`);
+    }
     const baseValue = baseList?.find(item => deepEqual(item.id, id))?.rating_modifier ?? 0;
     return renderInstance(id).thenW(name => translateR("{$replacement} instead of {$base}", {
         replacement: `${name} ${(baseValue + rating_modifier).toFixed()}`,
@@ -420,11 +434,11 @@ const renderProfessionVariantText = (base, variant, translation) => translation.
         Reader.asks(env => variant.prerequisites === undefined
             ? []
             : [
-                printProfessionPrerequisites(env.getInstanceById, env.getResolvedSelectOptionById, {
+                `${env.translate("Prerequisites")}: ${printProfessionPrerequisites(env.getInstanceById, env.getResolvedSelectOptionById, {
                     ...env,
                     join: env.localeJoin,
                     compare: env.localeCompare,
-                }, variant.prerequisites),
+                }, variant.prerequisites)}`,
             ]),
         renderVariantOption(base, variant, "skill_specialization", renderVariantSkillSpecializationOption),
         renderVariantOption(base, variant, "languages_scripts", renderVariantLanguagesScriptsOption),
@@ -448,7 +462,8 @@ const renderProfessionVariantText = (base, variant, translation) => translation.
         renderRatedVariantChanges(base.combat_techniques, variant.combat_techniques, id => strictNameR(id)),
         renderRatedVariantChanges(base.skills, variant.skills, id => strictNameR("Skill", id)),
         renderRatedVariantChanges(base.spells, variant.spells, renderSpellworkName),
-        renderRatedVariantChanges(base.liturgical_chants, variant.liturgical_chants, renderLiturgicalChantName),
+        renderBlessingsForVariant(variant),
+        renderRatedVariantChanges(baseHasNoTradition(base) ? "ignore" : base.liturgical_chants, variant.liturgical_chants, renderLiturgicalChantName),
     ]).map(lists => lists
         .filter(isNotEmpty)
         .map(list => list.join(", "))