@optolith/entity-descriptions 0.4.7 → 0.4.10

package/lib/entities/partial/markdown.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Some helpers to create Markdown content.
+ */
+import type { EntityMap } from "optolith-database-schema/gen";
+import { type IdArgsVariant } from "tsondb/schema/gen";
+import type { GetInstanceById } from "../../helpers/getTypes.js";
+import type { LocaleMap, TranslateMap } from "../../helpers/translate.js";
+/**
+ * Creates an attributed string in Markdown format.
+ */
+export declare const attributedString: (text: string, rawAttributes: Partial<Record<string, string>>) => string;
+/**
+ * Display an instance of an entity in Markdown format.
+ */
+export declare const attributedInstance: (name: string, entity: string, id?: string, other?: Record<string, string>) => string;
+/**
+ * Renders the name of an instance in an attributed string.
+ */
+export declare const attributedName: <E extends { [K in keyof EntityMap]: EntityMap[K] extends {
+    translations: LocaleMap<{
+        name: string;
+    }>;
+} ? K : never; }[keyof EntityMap]>(translateMap: TranslateMap, getInstanceById: GetInstanceById<E>, context: string, ...args: IdArgsVariant<EntityMap, E>) => string | undefined;
+/**
+ * Renders the name of an instance according to a custom function.
+ */
+export declare const customName: <E extends { [K in keyof EntityMap]: EntityMap[K] extends {
+    translations: LocaleMap<object>;
+} ? K : never; }[keyof EntityMap]>(translateMap: TranslateMap, getInstanceById: GetInstanceById<E>, fn: (translation: EntityMap[E]["translations"][string]) => string, ...args: IdArgsVariant<EntityMap, E>) => string | undefined;
+/**
+ * Renders the name of an instance according to a custom function in an attributed string.
+ */
+export declare const attributedCustomName: <E extends { [K in keyof EntityMap]: EntityMap[K] extends {
+    translations: LocaleMap<object>;
+} ? K : never; }[keyof EntityMap]>(translateMap: TranslateMap, getInstanceById: GetInstanceById<E>, context: string, fn: (translation: EntityMap[E]["translations"][string]) => string, ...args: IdArgsVariant<EntityMap, E>) => string | undefined;
+/**
+ * Renders the name of an instance in an attributed string.
+ */
+export declare const attributedNameFromInstance: (translateMap: TranslateMap, instance: {
+    translations: LocaleMap<{
+        name: string;
+    }>;
+} | undefined, context: string, ...args: IdArgsVariant<EntityMap, keyof EntityMap>) => string | undefined;
+/**
+ * Renders the name of an instance in an attributed string.
+ */
+export declare const attributedNameFromTranslation: (translation: {
+    name: string;
+} | undefined, context: string, ...args: IdArgsVariant<EntityMap, keyof EntityMap>) => string | undefined;
+/**
+ * Renders the name of an instance in an attributed string.
+ */
+export declare const attributedNameFromSafeTranslation: (translation: {
+    name: string;
+}, context: string, ...args: IdArgsVariant<EntityMap, keyof EntityMap>) => string;

package/lib/entities/partial/markdown.js

@@ -0,0 +1,59 @@
+/**
+ * Some helpers to create Markdown content.
+ */
+import { mapNullable } from "@elyukai/utils/nullable";
+import { normalizedIdArgs } from "tsondb/schema/gen";
+/**
+ * Creates an attributed string in Markdown format.
+ */
+export const attributedString = (text, rawAttributes) => `^[${text}](${Object.entries(rawAttributes)
+    .filter((pair) => pair[1] !== undefined)
+    .map(([key, value]) => `${key}: ${value}`)
+    .join(", ")})`;
+/**
+ * Display an instance of an entity in Markdown format.
+ */
+export const attributedInstance = (name, entity, id, other) => attributedString(name, {
+    ...other,
+    entity: `"${entity}"`,
+    instance: id === undefined ? undefined : `"${id}"`,
+});
+/**
+ * Renders the name of an instance in an attributed string.
+ */
+export const attributedName = (translateMap, getInstanceById, context, ...args) => {
+    const id = normalizedIdArgs(args);
+    return mapNullable(translateMap(getInstanceById(...args)?.translations)?.name, name => attributedInstance(name, id.entityName, id.id, { context: `"${context}"` }));
+};
+/**
+ * Renders the name of an instance according to a custom function.
+ */
+export const customName = (translateMap, getInstanceById, fn, ...args) => mapNullable(translateMap(getInstanceById(...args)?.translations), translation => fn(translation));
+/**
+ * Renders the name of an instance according to a custom function in an attributed string.
+ */
+export const attributedCustomName = (translateMap, getInstanceById, context, fn, ...args) => {
+    const id = normalizedIdArgs(args);
+    return mapNullable(translateMap(getInstanceById(...args)?.translations), translation => attributedInstance(fn(translation), id.entityName, id.id, { context: `"${context}"` }));
+};
+/**
+ * Renders the name of an instance in an attributed string.
+ */
+export const attributedNameFromInstance = (translateMap, instance, context, ...args) => {
+    const id = normalizedIdArgs(args);
+    return mapNullable(translateMap(instance?.translations)?.name, name => attributedInstance(name, id.entityName, id.id, { context: `"${context}"` }));
+};
+/**
+ * Renders the name of an instance in an attributed string.
+ */
+export const attributedNameFromTranslation = (translation, context, ...args) => {
+    const id = normalizedIdArgs(args);
+    return mapNullable(translation?.name, name => attributedInstance(name, id.entityName, id.id, { context: `"${context}"` }));
+};
+/**
+ * Renders the name of an instance in an attributed string.
+ */
+export const attributedNameFromSafeTranslation = (translation, context, ...args) => {
+    const id = normalizedIdArgs(args);
+    return attributedInstance(translation.name, id.entityName, id.id, { context: `"${context}"` });
+};

package/lib/entities/partial/prerequisites/index.d.ts

@@ -20,7 +20,7 @@ export declare const printPlainGeneralPrerequisites: (getInstanceById: GetInstan
 export declare const printGeneralPrerequisites: (getInstanceById: GetInstanceById<"Race" | "Culture" | "PactCategory" | "PactDomain" | "SocialStatus" | "State" | ActivatableIdentifier["kind"] | RatedIdentifier["kind"] | "Property" | "Aspect" | "Enhancement">, getResolvedSelectOptionById: GetResolvedSelectOptionById, locale: LocaleEnvironment, value: GeneralPrerequisites, printPreviousLevelPrerequisites?: {
     id: SpecialAbilityIdentifier;
     levels: number;
-}) => string;
+}, trailingText?: string) => string;
 /**
  * Print profession prerequisites as a string.
  */

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

@@ -78,17 +78,20 @@ const printPrerequisiteForLevel = (printPrerequisite, locale, value) => printPre
 /**
  * Print prerequisites for levels as a string.
  */
-const printPrerequisitesForLevels = (printPrerequisite, locale, value, printPreviousLevelPrerequisites) => {
+const printPrerequisitesForLevels = (printPrerequisite, locale, value, printPreviousLevelPrerequisites, trailingText) => {
     const previousLevelPrerequisites = printPreviousLevelPrerequisites === undefined
         ? []
         : Array.from({ length: printPreviousLevelPrerequisites.levels - 1 }, (_, i) => ({
             level: i + 2,
             prerequisite: {
                 kind: "Single",
-                Single: printPreviousLevelPrerequisites.createPreerequisite(i + 2),
+                Single: printPreviousLevelPrerequisites.createPrerequisite(i + 1),
             },
         }));
     const groupedByLevel = Map.groupBy([...value, ...previousLevelPrerequisites], prerequisite => prerequisite.level);
+    if (trailingText !== undefined && !groupedByLevel.has(1)) {
+        groupedByLevel.set(1, []);
+    }
     const hasBasePrerequisites = groupedByLevel.has(1);
     const sortedByLevel = groupedByLevel
         .entries()
@@ -104,14 +107,24 @@ const printPrerequisitesForLevels = (printPrerequisite, locale, value, printPrev
                 })}: ${locale.translate("none")}`,
             ]),
         ...sortedByLevel.map(([levelNumber, prerequisites]) => {
-            const prerequisitesString = joinPrerequisiteParts(locale.translate, locale.translateMap, locale.compare, prerequisites
-                .map(element => mapNullable(printPrerequisiteForLevel(printPrerequisite, locale, element), part => ({
-                type: element.prerequisite.kind === "Single"
-                    ? element.prerequisite.Single.kind
-                    : element.prerequisite.kind,
-                part,
-            })))
-                .filter(isNotNullish));
+            const prerequisitesString = joinPrerequisiteParts(locale.translate, locale.translateMap, locale.compare, [
+                ...prerequisites
+                    .map(element => mapNullable(printPrerequisiteForLevel(printPrerequisite, locale, element), part => ({
+                    type: element.prerequisite.kind === "Single"
+                        ? element.prerequisite.Single.kind
+                        : element.prerequisite.kind,
+                    part,
+                })))
+                    .filter(isNotNullish),
+                ...(levelNumber === 1 && trailingText !== undefined
+                    ? [
+                        {
+                            type: "trailing",
+                            part: { value: trailingText, sentenceType: undefined, isMeta: false },
+                        },
+                    ]
+                    : []),
+            ]);
             return hasOnlyBasePrerequisites
                 ? prerequisitesString
                 : `${locale.translate("Level {$level}", {
@@ -136,11 +149,11 @@ export const printPlainGeneralPrerequisites = (getInstanceById, getResolvedSelec
 /**
  * Print general prerequisites as a string.
  */
-export const printGeneralPrerequisites = (getInstanceById, getResolvedSelectOptionById, locale, value, printPreviousLevelPrerequisites) => printPrerequisitesForLevels(prerequisite => printGeneralPrerequisiteGroup(getInstanceById, getResolvedSelectOptionById, locale, prerequisite), locale, value, printPreviousLevelPrerequisites === undefined
+export const printGeneralPrerequisites = (getInstanceById, getResolvedSelectOptionById, locale, value, printPreviousLevelPrerequisites, trailingText) => printPrerequisitesForLevels(prerequisite => printGeneralPrerequisiteGroup(getInstanceById, getResolvedSelectOptionById, locale, prerequisite), locale, value, printPreviousLevelPrerequisites === undefined
     ? undefined
     : {
         levels: printPreviousLevelPrerequisites.levels,
-        createPreerequisite: (level) => ({
+        createPrerequisite: (level) => ({
             kind: "Activatable",
             Activatable: {
                 id: printPreviousLevelPrerequisites.id,
@@ -148,7 +161,7 @@ export const printGeneralPrerequisites = (getInstanceById, getResolvedSelectOpti
                 level,
             },
         }),
-    });
+    }, trailingText);
 /**
  * Print profession prerequisites as a string.
  */

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

@@ -5,6 +5,7 @@ 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";
+import { attributedInstance } from "../markdown.js";
 /**
  * Type guard for prerequisite parts with a value object.
  */
@@ -18,15 +19,19 @@ const countFurtherToCombined = (part, remainingParts) => {
             remainingParts.length
         : indexHasDifferentBaseValues;
 };
+const wrapActivatableInAttributedString = (text, id) => attributedInstance(text, id.kind, fromUniformCase(id), { context: '"prerequisite"' });
 const joinAdjacentParts = (translateMap, localeCompare, part, remainingParts) => {
     const valuesWithSameBase = remainingParts.slice(0, countFurtherToCombined(part, remainingParts));
     if (valuesWithSameBase.length > 0) {
         return [
-            renderActivatableNameComponentsCombinedIfPossible(translateMap, [part.value, ...valuesWithSameBase.map(p => p.value)], true, list => list.toSorted(localeCompare).join(", ")),
+            wrapActivatableInAttributedString(renderActivatableNameComponentsCombinedIfPossible(translateMap, [part.value, ...valuesWithSameBase.map(p => p.value)], true, list => list.toSorted(localeCompare).join(", ")), part.value.id),
             valuesWithSameBase.length,
         ];
     }
-    return [renderActivatableNameComponents(translateMap, part.value, true), 0];
+    return [
+        wrapActivatableInAttributedString(renderActivatableNameComponents(translateMap, part.value, true), part.value.id),
+        0,
+    ];
 };
 const appendBySentenceType = (previouslyRendered, currentRendered, sentenceType, isLast) => {
     switch (sentenceType?.kind) {
@@ -76,7 +81,7 @@ const appendPrerequisitePartGroup = (previous, translateMap, localeCompare, part
         return parts.reduce((acc, current, i, arr) => appendBySentenceType(acc, (current.label ?? "") +
             (typeof current.value === "string"
                 ? current.value
-                : renderActivatableNameComponents(translateMap, current.value, true)), current.sentenceType, isLast && i === arr.length - 1), previous);
+                : wrapActivatableInAttributedString(renderActivatableNameComponents(translateMap, current.value, true), current.value.id)), current.sentenceType, isLast && i === arr.length - 1), previous);
     }
 };
 /**

package/lib/entities/partial/prerequisites/single/culture.js

@@ -1,3 +1,4 @@
+import { attributedNameFromSafeTranslation } from "../../markdown.js";
 import { printDisplayOption } from "../displayOption.js";
 /**
  * Get the translation of a culture prerequisite.
@@ -13,7 +14,7 @@ export const printCulturePrerequisite = (getInstanceById, locale, prerequisite)
     }
     return {
         label: `${locale.translate("Culture")} `,
-        value: cultureTranslation.name,
+        value: attributedNameFromSafeTranslation(cultureTranslation, "prerequisite", "Culture", prerequisite.id),
         sentenceType: undefined,
         isMeta: false,
     };

package/lib/entities/partial/prerequisites/single/personalityTrait.js

@@ -1,3 +1,4 @@
+import { attributedNameFromSafeTranslation } from "../../markdown.js";
 import { printDisplayOption } from "../displayOption.js";
 /**
  * Get the translation of a personality trait prerequisite.
@@ -11,7 +12,7 @@ export const printPersonalityTraitPrerequisite = (getInstanceById, locale, prere
     if (personalityTrait === undefined || personalityTraitTranslation === undefined) {
         return undefined;
     }
-    const name = `${personalityTraitTranslation.name} (${locale.translate("Level {$level}", {
+    const name = `${attributedNameFromSafeTranslation(personalityTraitTranslation, "prerequisite", "PersonalityTrait", prerequisite.id)} (${locale.translate("Level {$level}", {
         level: personalityTrait.level,
     })})`;
     return {

package/lib/entities/partial/prerequisites/single/profession.js

@@ -1,3 +1,4 @@
+import { attributedInstance } from "../../markdown.js";
 import { getProfessionName } from "../../professions.js";
 import { printDisplayOption } from "../displayOption.js";
 /**
@@ -12,7 +13,9 @@ export const printProfessionPrerequisite = (getChildInstancesForInstanceId, loca
         return undefined;
     }
     return {
-        value: professionName,
+        value: attributedInstance(professionName, "Profession", prerequisite.id, {
+            context: '"prerequisite"',
+        }),
         sentenceType: undefined,
         isMeta: false,
     };

package/lib/entities/partial/prerequisites/single/race.js

@@ -1,3 +1,4 @@
+import { attributedNameFromSafeTranslation } from "../../markdown.js";
 import { printDisplayOption } from "../displayOption.js";
 /**
  * Get the translation of a race prerequisite.
@@ -13,7 +14,7 @@ export const printRacePrerequisite = (getInstanceById, locale, prerequisite) =>
     }
     return {
         label: `${locale.translate("Race")} `,
-        value: raceTranslation.name,
+        value: attributedNameFromSafeTranslation(raceTranslation, "prerequisite", "Race", prerequisite.id),
         sentenceType: undefined,
         isMeta: false,
     };

package/lib/entities/partial/prerequisites/single/rated.js

@@ -1,31 +1,6 @@
-import { assertExhaustive } from "@optolith/helpers/typeSafety";
+import { attributedName } from "../../markdown.js";
 import { MISSING_VALUE } from "../../unknown.js";
 import { printDisplayOption } from "../displayOption.js";
-const printRatedName = (getInstanceById, translateMap, id) => {
-    switch (id.kind) {
-        case "Attribute":
-            return (translateMap(getInstanceById("Attribute", id.Attribute)?.translations)?.abbreviation ??
-                MISSING_VALUE);
-        case "Skill":
-            return translateMap(getInstanceById("Skill", id.Skill)?.translations)?.name ?? MISSING_VALUE;
-        case "CloseCombatTechnique":
-            return (translateMap(getInstanceById("CloseCombatTechnique", id.CloseCombatTechnique)?.translations)
-                ?.name ?? MISSING_VALUE);
-        case "RangedCombatTechnique":
-            return (translateMap(getInstanceById("RangedCombatTechnique", id.RangedCombatTechnique)?.translations)?.name ?? MISSING_VALUE);
-        case "Spell":
-            return translateMap(getInstanceById("Spell", id.Spell)?.translations)?.name ?? MISSING_VALUE;
-        case "Ritual":
-            return translateMap(getInstanceById("Ritual", id.Ritual)?.translations)?.name ?? MISSING_VALUE;
-        case "LiturgicalChant":
-            return (translateMap(getInstanceById("LiturgicalChant", id.LiturgicalChant)?.translations)?.name ??
-                MISSING_VALUE);
-        case "Ceremony":
-            return (translateMap(getInstanceById("Ceremony", id.Ceremony)?.translations)?.name ?? MISSING_VALUE);
-        default:
-            return assertExhaustive(id);
-    }
-};
 /**
  * Get the translation of a blessed tradition prerequisite.
  */
@@ -34,7 +9,7 @@ export const printRatedPrerequisite = (getInstanceById, locale, prerequisite) =>
         return printDisplayOption(locale.translateMap, prerequisite.display_option);
     }
     return {
-        value: `${printRatedName(getInstanceById, locale.translateMap, prerequisite.id)} ${prerequisite.value.toFixed()}`,
+        value: `${attributedName(locale.translateMap, getInstanceById, "prerequisite", prerequisite.id) ?? MISSING_VALUE} ${prerequisite.value.toFixed()}`,
         sentenceType: undefined,
         isMeta: false,
     };

package/lib/entities/partial/prerequisites/single/ratedMinimumNumber.js

@@ -1,5 +1,6 @@
 import { isNotNullish } from "@optolith/helpers/nullable";
 import { assertExhaustive } from "@optolith/helpers/typeSafety";
+import { attributedName } from "../../markdown.js";
 import { MISSING_VALUE } from "../../unknown.js";
 import { printDisplayOption } from "../displayOption.js";
 const printNumberOfTheFollowingSkills = (locale, number) => locale.translate(".input {$count :number} {{{$count} of the following skills}}", {
@@ -36,7 +37,7 @@ export const printRatedMinimumNumberPrerequisite = (getInstanceById, locale, pre
     switch (prerequisite.targets.kind) {
         case "Skills": {
             const skills = prerequisite.targets.Skills.targets
-                .map(id => locale.translateMap(getInstanceById("Skill", id)?.translations)?.name)
+                .map(id => attributedName(locale.translateMap, getInstanceById, "prerequisite", "Skill", id))
                 .filter(isNotNullish);
             return {
                 value: locale.translate(".input {$minRating :number} {{{$count} on at least SR {$minRating}: {$list}}}", // zwei der folgenden Talente mindestens FW 10:

package/lib/entities/partial/prerequisites/single/ratedSum.js

@@ -1,4 +1,5 @@
 import { isNotNullish } from "@optolith/helpers/nullable";
+import { attributedName } from "../../markdown.js";
 import { printDisplayOption } from "../displayOption.js";
 /**
  * Get the translation of a rated sum prerequisite.
@@ -8,7 +9,7 @@ export const printRatedSumPrerequisite = (getInstanceById, locale, prerequisite)
         return printDisplayOption(locale.translateMap, prerequisite.display_option);
     }
     const skills = prerequisite.targets
-        .map(skillId => locale.translateMap(getInstanceById("Skill", skillId)?.translations)?.name)
+        .map(skillId => attributedName(locale.translateMap, getInstanceById, "prerequisite", "Skill", skillId))
         .filter(isNotNullish);
     return {
         value: locale.translate("the SR for {$skill} combined must add up to at least {$minRating}", {

package/lib/entities/partial/prerequisites/single/state.js

@@ -1,3 +1,4 @@
+import { attributedNameFromSafeTranslation } from "../../markdown.js";
 import { printDisplayOption } from "../displayOption.js";
 /**
  * Get the translation of a state prerequisite.
@@ -13,7 +14,7 @@ export const printStatePrerequisite = (getInstanceById, locale, prerequisite) =>
     }
     return {
         label: `${locale.translate("State")} `,
-        value: `*${stateTranslation.name}*`,
+        value: attributedNameFromSafeTranslation(stateTranslation, "prerequisite", "State", prerequisite.id),
         sentenceType: undefined,
         isMeta: false,
     };

package/lib/entities/partial/reader.d.ts

@@ -133,6 +133,39 @@ export declare const strictNameR: <E extends { [K in keyof EntityMap]: EntityMap
     translateMap: TranslateMap;
     getInstanceById: GetInstanceById<E>;
 }, string>;
+/**
+ * Retrieves the `name` property of the specified entry in an attributed string.
+ */
+export declare const attributedNameR: <E extends { [K in keyof EntityMap]: EntityMap[K] extends {
+    translations: LocaleMap<{
+        name: string;
+    }>;
+} ? K : never; }[keyof EntityMap]>(context: string, ...args: IdArgsVariant<EntityMap, E>) => Reader<{
+    translateMap: TranslateMap;
+    getInstanceById: GetInstanceById<E>;
+}, string | undefined>;
+/**
+ * Applies a function to the translation of the specified entry and renders it in an attributed string.
+ */
+export declare const attributedCustomNameR: <E extends { [K in keyof EntityMap]: EntityMap[K] extends {
+    translations: LocaleMap<{
+        name: string;
+    }>;
+} ? K : never; }[keyof EntityMap]>(context: string, fn: (translation: EntityMap[E]["translations"][string]) => string, ...args: IdArgsVariant<EntityMap, E>) => Reader<{
+    translateMap: TranslateMap;
+    getInstanceById: GetInstanceById<E>;
+}, string | undefined>;
+/**
+ * Applies a function to the translation of the specified entry.
+ */
+export declare const customNameR: <E extends { [K in keyof EntityMap]: EntityMap[K] extends {
+    translations: LocaleMap<{
+        name: string;
+    }>;
+} ? K : never; }[keyof EntityMap]>(fn: (translation: EntityMap[E]["translations"][string]) => string, ...args: IdArgsVariant<EntityMap, E>) => Reader<{
+    translateMap: TranslateMap;
+    getInstanceById: GetInstanceById<E>;
+}, string | undefined>;
 /**
  * Joins a list of strings according to the locale’s rules for the given type.
  */

package/lib/entities/partial/reader.js

@@ -1,6 +1,7 @@
 import { isNotNullish } from "@elyukai/utils/nullable";
 import { Reader } from "@elyukai/utils/reader";
 import { assertExhaustive } from "@elyukai/utils/typeSafety";
+import { attributedCustomName, attributedName, customName } from "./markdown.js";
 import { Speed } from "./rated/activatable/speed.js";
 import { responsive, ResponsiveTextSize } from "./responsiveText.js";
 import { formatEnergy } from "./units/energy.js";
@@ -50,6 +51,18 @@ export const nameR = (...args) => Reader.asks(env => env.translateMap(env.getIns
  * Returns {@link MISSING_VALUE} if there is no name for the entry in the locale. This can happen if the entry itself does not exist, or it does not have a translation for the current locale.
  */
 export const strictNameR = (...args) => nameR(...args).map(name => name ?? MISSING_VALUE);
+/**
+ * Retrieves the `name` property of the specified entry in an attributed string.
+ */
+export const attributedNameR = (context, ...args) => Reader.asks(env => attributedName(env.translateMap, env.getInstanceById, context, ...args));
+/**
+ * Applies a function to the translation of the specified entry and renders it in an attributed string.
+ */
+export const attributedCustomNameR = (context, fn, ...args) => Reader.asks(env => attributedCustomName(env.translateMap, env.getInstanceById, context, fn, ...args));
+/**
+ * Applies a function to the translation of the specified entry.
+ */
+export const customNameR = (fn, ...args) => Reader.asks(env => customName(env.translateMap, env.getInstanceById, fn, ...args));
 /**
  * Joins a list of strings according to the locale’s rules for the given type.
  */

package/lib/entities/partial/unknown.d.ts

@@ -5,4 +5,4 @@ export declare const MISSING_VALUE = "###MISSING###";
 /**
  * String to display when a translation that should be present produces an error.
  */
-export declare const UNHANDLED_VALUE = "###UNHANDLED_ERROR###";
+export declare const UNHANDLED_VALUE = "###UNHANDLEDERROR###";

package/lib/entities/partial/unknown.js

@@ -5,4 +5,4 @@ export const MISSING_VALUE = "###MISSING###";
 /**
  * String to display when a translation that should be present produces an error.
  */
-export const UNHANDLED_VALUE = "###UNHANDLED_ERROR###";
+export const UNHANDLED_VALUE = "###UNHANDLEDERROR###";

package/lib/entities/personalityTrait.js

@@ -1,8 +1,10 @@
 import { on } from "@elyukai/utils/function";
+import { mapNullable } from "@elyukai/utils/nullable";
 import { compareNullish } from "@elyukai/utils/ordering";
 import { romanize } from "@elyukai/utils/roman";
 import { numAsc } from "@optolith/helpers/compare";
 import { createEntityDescriptionCreator } from "../creator.js";
+import { attributedNameFromInstance } from "./partial/markdown.js";
 import { printPersonalityTraitPrerequisites } from "./partial/prerequisites/index.js";
 import { MISSING_VALUE } from "./partial/unknown.js";
 /**
@@ -31,13 +33,18 @@ export const getPersonalityTraitEntityDescription = createEntityDescriptionCreat
                         ? undefined
                         : {
                             label: translate("Can be combined with"),
-                            value: Map.groupBy(entry.combination_options.map(optionId => getInstanceById("PersonalityTrait", optionId)), option => option?.level ?? null)
+                            value: Map.groupBy(entry.combination_options.map(optionId => mapNullable(getInstanceById("PersonalityTrait", optionId), pt => ({
+                                id: optionId,
+                                content: pt,
+                            }))), option => option?.content.level ?? null)
                                 .entries()
                                 .toArray()
                                 .toSorted(on(group => group[0], compareNullish(numAsc)))
                                 .map(([level, options]) => level === null
                                 ? MISSING_VALUE
-                                : `${translate("Level {$level}", { level: romanize(level) })} ${localeJoin(options.map(option => translateMap(option?.translations)?.name ?? MISSING_VALUE), "disjunction")}`)
+                                : `${translate("Level {$level}", { level: romanize(level) })} ${localeJoin(options.map(option => (option &&
+                                    attributedNameFromInstance(translateMap, option.content, "prerequisite", "PersonalityTrait", option.id)) ??
+                                    MISSING_VALUE), "disjunction")}`)
                                 .join(", "),
                         },
                     entry.prerequisites === undefined