@optolith/entity-descriptions 0.4.7 → 0.4.10

package/lib/entities/profession.js

@@ -7,12 +7,14 @@ import { omitKeys } from "@elyukai/utils/object";
 import { compareNumber } from "@elyukai/utils/ordering";
 import { Reader } from "@elyukai/utils/reader";
 import { assertExhaustive } from "@elyukai/utils/typeSafety";
+import { fromUniformCase } from "tsondb/schema/gen";
 import { createEntityDescriptionCreator } from "../creator.js";
 import { combineNameComponents, getNameComponents, renderActivatableNameComponents, renderCombinedActivatableNameComponents, } from "./partial/activatableNameChunks.js";
 import { renderCommonnessRatedAdvantagesOrDisadvantages, renderValueWithPossibleTranslation, } from "./partial/commonnessRatedAdvantagesAndDisadvantages.js";
+import { attributedCustomName, attributedInstance, attributedName } from "./partial/markdown.js";
 import { printProfessionPrerequisites } from "./partial/prerequisites/index.js";
 import { parensIf } from "./partial/rated/activatable/parensIf.js";
-import { formatR, getChildInstancesForInstanceIdR, getInstanceByIdR, localeCompareR, localeJoinR, localeSortR, nameR, strictNameR, translateMapFnR, translateR, translationR, } from "./partial/reader.js";
+import { attributedCustomNameR, attributedNameR, customNameR, formatR, getChildInstancesForInstanceIdR, getInstanceByIdR, localeCompareR, localeJoinR, localeSortR, strictNameR, translateMapFnR, translateR, translationR, } from "./partial/reader.js";
 import { MISSING_VALUE, UNHANDLED_VALUE } from "./partial/unknown.js";
 const prepareProfessionPackages = (professionId) => Reader.asks(({ getInstanceById, getChildInstancesForInstanceId }) => getChildInstancesForInstanceId("ProfessionPackage", professionId)
     .map((professionPackage) => ({
@@ -79,12 +81,12 @@ const renderSkillSpecializationOption = (option) => Reader.asks(({ format, trans
     switch (option.kind) {
         case "Specific":
             return translate("Skill Specialization {$possibleSkills}", {
-                possibleSkills: localeJoin(option.Specific.options.map(id => translateMap(getInstanceById("Skill", id)?.translations)?.name ?? MISSING_VALUE), "disjunction"),
+                possibleSkills: localeJoin(option.Specific.options.map(id => attributedName(translateMap, getInstanceById, "profession", "Skill", id) ??
+                    MISSING_VALUE), "disjunction"),
             });
         case "Group":
             return translate("Skill Specialization for a {$skillOfGroup}", {
-                skillOfGroup: format(translateMap(getInstanceById("SkillGroup", option.Group)?.translations)?.longName ??
-                    MISSING_VALUE, { hiddenCount: 1 }),
+                skillOfGroup: format(attributedCustomName(translateMap, getInstanceById, "profession", t => t.longName, "SkillGroup", option.Group) ?? MISSING_VALUE, { hiddenCount: 1 }),
             });
         default:
             return assertExhaustive(option);
@@ -105,7 +107,7 @@ const renderCombatTechniquesOption = (option) => isNotEmpty(option.fixed)
                 previous: fixedText,
                 rating: option.rest_rating_modifier + 6,
             }));
-        const listR = Reader.traverse(option.options, strictNameR)
+        const listR = Reader.traverse(option.options, id => attributedNameR("profession", id).map(name => name ?? MISSING_VALUE))
             .thenW(list => localeSortR(list))
             .map(list => list.join(", "));
         return completeTextR.thenW(completeText => listR.map(list => `${completeText}: ${list}`));
@@ -125,7 +127,7 @@ const renderSkillsOption = (professionPackages, skillGroup) => mapNullable(getTo
     apValue,
     skillsOfGroup: skillGroup.nameOfSkillsOfGroup,
 })) ?? Reader.of(undefined);
-const renderCantripList = (cantripIds) => Reader.traverse(cantripIds, id => strictNameR("Cantrip", id))
+const renderCantripList = (cantripIds) => Reader.traverse(cantripIds, id => attributedNameR("profession", "Cantrip", id).map(name => name ?? MISSING_VALUE))
     .thenW(localeSortR)
     .map(list => list.join(", "));
 const renderVariantCantripsOption = (baseOptions, variantOptions) => renderVariantOptionPaths(baseOptions, variantOptions, {
@@ -184,16 +186,15 @@ const renderVariantSkillSpecializationOption = (baseOptions, variantOptions) =>
     remove: (base) => {
         switch (base.kind) {
             case "Specific":
-                return Reader.traverse(base.Specific.options, id => strictNameR("Skill", id))
+                return Reader.traverse(base.Specific.options, id => attributedNameR("profession", "Skill", id).map(name => name ?? MISSING_VALUE))
                     .thenW(localeSortR)
                     .thenW(list => localeJoinR(list, "disjunction"))
                     .thenW(skillsText => translateR("no Skill Specialization {$possibleSkills}", {
                     possibleSkills: skillsText,
                 }));
             case "Group":
-                return getInstanceByIdR("SkillGroup", base.Group)
-                    .thenW(translationR)
-                    .map(t => t?.longName ?? MISSING_VALUE)
+                return attributedCustomNameR("profession", t => t.longName, "SkillGroup", base.Group)
+                    .map(name => name ?? MISSING_VALUE)
                     .thenW(longName => formatR(longName, { hiddenCount: 1 }))
                     .thenW(skillOfGroup => translateR("no Skill Specialization for a {$skillOfGroup}", {
                     skillOfGroup,
@@ -205,8 +206,8 @@ const renderVariantSkillSpecializationOption = (baseOptions, variantOptions) =>
     add: override => renderSkillSpecializationOption(override),
     update: (base, override) => {
         if (base.kind === "Specific" && override.kind === "Specific") {
-            const overrideSkills = Reader.traverse(override.Specific.options, id => strictNameR("Skill", id)).thenW(list => localeJoinR(list, "disjunction"));
-            const baseSkills = Reader.traverse(base.Specific.options, id => strictNameR("Skill", id)).thenW(list => localeJoinR(list, "disjunction"));
+            const overrideSkills = Reader.traverse(override.Specific.options, id => attributedNameR("profession", "Skill", id).map(name => name ?? MISSING_VALUE)).thenW(list => localeJoinR(list, "disjunction"));
+            const baseSkills = Reader.traverse(base.Specific.options, id => attributedNameR("profession", "Skill", id).map(name => name ?? MISSING_VALUE)).thenW(list => localeJoinR(list, "disjunction"));
             return overrideSkills
                 .thenW(overrideSkillsText => baseSkills.thenW(baseSkillsText => insteadOfR(overrideSkillsText, baseSkillsText)))
                 .then(skillsText => translateR("Skill Specialization {$possibleSkills}", {
@@ -234,9 +235,7 @@ const renderVariantCursesOption = (baseOptions, variantOptions) => renderVariant
     })),
 });
 const renderCursesOption = (option) => renderVariantCursesOption(undefined, { kind: "Override", Override: option });
-const nameOfSkillsOfGroupR = (skillGroupId) => getInstanceByIdR("SkillGroup", skillGroupId)
-    .thenW(translationR)
-    .map(t => t?.longName ?? MISSING_VALUE);
+const nameOfSkillsOfGroupR = (skillGroupId) => customNameR(t => t.longName, "SkillGroup", skillGroupId).map(name => name ?? MISSING_VALUE);
 const renderVariantSkillsOption = (baseOptions, variantOptions) => renderVariantOptionPaths(baseOptions, variantOptions, {
     remove: base => nameOfSkillsOfGroupR(base.group).thenW(nameOfSkillsOfGroup => translateR("no AP to improve other {$skillsOfGroup}", {
         skillsOfGroup: nameOfSkillsOfGroup,
@@ -264,13 +263,14 @@ const getSpecialAbilityNameComponents = (getInstanceById, getResolvedSelectOptio
     }
     return getNameComponents(translate, option.id, option.options, option.level, "nameBuilderRules" in instance ? instance.nameBuilderRules : undefined, instance.translations, t => t.name, getResolvedSelectOptionById, true);
 };
+const wrapActivatableInAttributedString = (text, id) => attributedInstance(text, id.kind, fromUniformCase(id), { context: '"prerequisite"' });
 const renderSpecialAbilityName = (specialAbility) => Reader.asks(({ translate, translateMap, localeJoin, getInstanceById, getResolvedSelectOptionById, }) => {
     switch (specialAbility.kind) {
         case "Constant": {
             const chunk = getSpecialAbilityNameComponents(getInstanceById, getResolvedSelectOptionById, translate, specialAbility.Constant);
             return chunk === undefined
                 ? MISSING_VALUE
-                : renderActivatableNameComponents(translateMap, chunk, false);
+                : wrapActivatableInAttributedString(renderActivatableNameComponents(translateMap, chunk, false), chunk.id);
         }
         case "Selection": {
             const chunks = specialAbility.Selection.options.map(option => getSpecialAbilityNameComponents(getInstanceById, getResolvedSelectOptionById, translate, option));
@@ -280,10 +280,10 @@ const renderSpecialAbilityName = (specialAbility) => Reader.asks(({ translate, t
             if (possiblyCombined === undefined) {
                 return localeJoin(chunks.map(chunk => chunk === undefined
                     ? MISSING_VALUE
-                    : renderActivatableNameComponents(translateMap, chunk, false)), "disjunction");
+                    : wrapActivatableInAttributedString(renderActivatableNameComponents(translateMap, chunk, false), chunk.id)), "disjunction");
             }
             else {
-                return renderCombinedActivatableNameComponents(translateMap, possiblyCombined, false, list => localeJoin(list, "disjunction"));
+                return wrapActivatableInAttributedString(renderCombinedActivatableNameComponents(translateMap, possiblyCombined, false, list => localeJoin(list, "disjunction")), possiblyCombined.id);
             }
         }
         default:
@@ -310,7 +310,7 @@ const renderSpecialAbilities = (specialAbilities) => Reader.sequence([
     return result === undefined ? translateR("none") : Reader.of(result);
 });
 const renderCombatTechniques = (professionPackages) => Reader.sequence([
-    renderNumericListAcrossPackages(professionPackages, pkg => Reader.of(pkg.content.combat_techniques?.map(ct => [ct.id, ct.rating_modifier]) ?? []), deepEqual, (ctId) => strictNameR(ctId), 6),
+    renderNumericListAcrossPackages(professionPackages, pkg => Reader.of(pkg.content.combat_techniques?.map(ct => [ct.id, ct.rating_modifier]) ?? []), deepEqual, (ctId) => attributedNameR("profession", ctId).map(name => name ?? MISSING_VALUE), 6),
     professionPackages.some(pkg => pkg.content.options?.combat_techniques !== undefined)
         ? renderSinglePackageValue(professionPackages, pkg => Reader.of(pkg.content.options?.combat_techniques), deepEqual, options => Reader.traverse(options, option => option === undefined ? Reader.of("—") : renderCombatTechniquesOption(option)).map(renderedOptions => renderedOptions.join(" / ")))
         : Reader.of(undefined),
@@ -318,7 +318,7 @@ const renderCombatTechniques = (professionPackages) => Reader.sequence([
 const renderSkills = (professionPackages) => Reader.asks(({ getAllInstances }) => getAllInstances("SkillGroup")).thenW(skillGroups => Reader.traverse(skillGroups.toSorted(on(group => group.content.position, compareNumber)), ({ id: groupId, content: group }) => translationR(group).thenW(groupTranslation => Reader.sequence([
     renderNumericListAcrossPackages(professionPackages, pkg => Reader.asks(({ getInstanceById }) => pkg.content.skills
         ?.filter(skill => getInstanceById("Skill", skill.id)?.group === groupId)
-        .map(skill => [skill.id, skill.rating_modifier]) ?? []), equal, skillId => strictNameR("Skill", skillId), 0),
+        .map(skill => [skill.id, skill.rating_modifier]) ?? []), equal, skillId => attributedNameR("profession", "Skill", skillId).map(name => name ?? MISSING_VALUE), 0),
     renderSkillsOption(professionPackages, {
         id: groupId,
         nameOfSkillsOfGroup: groupTranslation?.longName ?? MISSING_VALUE,
@@ -330,11 +330,11 @@ const renderSkills = (professionPackages) => Reader.asks(({ getAllInstances }) =
 const renderSpellworkName = (spellworkIds) => Reader.traverse(spellworkIds, spellworkId => {
     switch (spellworkId.kind) {
         case "Spellwork":
-            return strictNameR(spellworkId.Spellwork.id).thenW(baseName => (spellworkId.Spellwork.tradition === undefined
+            return attributedNameR("profession", spellworkId.Spellwork.id).thenW(baseName => (spellworkId.Spellwork.tradition === undefined
                 ? Reader.of(undefined)
-                : nameR("MagicalTradition", spellworkId.Spellwork.tradition)).map(traditionName => baseName + parensIf(traditionName)));
+                : attributedNameR("profession", "MagicalTradition", spellworkId.Spellwork.tradition)).map(traditionName => (baseName ?? MISSING_VALUE) + parensIf(traditionName)));
         case "MagicalAction":
-            return strictNameR(spellworkId.MagicalAction.id);
+            return attributedNameR("profession", spellworkId.MagicalAction.id).map(name => name ?? MISSING_VALUE);
         default:
             return spellworkId;
     }
@@ -358,7 +358,7 @@ const retrieveBlessedTraditionIdentifierFromPrerequisites = (prerequisites) => p
             return assertExhaustive(part);
     }
 }) ?? [];
-const renderBlessingList = (blessings) => Reader.traverse(blessings, id => strictNameR("Blessing", id)).thenW(localeSortR);
+const renderBlessingList = (blessings) => Reader.traverse(blessings, id => attributedNameR("profession", "Blessing", id).map(name => name ?? MISSING_VALUE)).thenW(localeSortR);
 const renderRestrictedBlessings = (restrictedBlessings) => {
     switch (restrictedBlessings.kind) {
         case "Three":
@@ -406,7 +406,7 @@ const renderBlessingsForPackages = (professionPackages) => renderBlessings(profe
 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 renderLiturgicalChantName = (liturgyIds) => Reader.traverse(liturgyIds, id => attributedNameR("profession", id).map(name => name ?? MISSING_VALUE)).thenW(list => localeJoinR(list, "disjunction"));
 const renderLiturgicalChants = (professionPackages) => Reader.sequence([
     renderBlessingsForPackages(professionPackages),
     renderNumericListAcrossPackages(professionPackages, (pkg) => Reader.of(pkg.content.liturgical_chants?.map(ct => [ct.id, ct.rating_modifier]) ?? []), deepEqual, renderLiturgicalChantName, 0),

package/lib/entities/race.js

@@ -7,13 +7,14 @@ import { Reader } from "@elyukai/utils/reader";
 import { sign } from "@elyukai/utils/string/number";
 import { createEntityDescriptionCreator } from "../creator.js";
 import { renderCommonnessRatedAdvantagesAndDisadvantages, renderCommonnessRatedAdvantagesOrDisadvantages, renderValueWithPossibleTranslation, } from "./partial/commonnessRatedAdvantagesAndDisadvantages.js";
+import { attributedCustomName, attributedName } from "./partial/markdown.js";
 import { MISSING_VALUE } from "./partial/unknown.js";
 const renderBaseValueItem = (label, value) => Reader.asks(({ translate }) => ({
     label: translate(label),
     value: value < 0 ? sign(value) : value.toFixed(),
 }));
 const renderAttributeAdjustmentsItem = (totalAttributesCount, adjustments) => Reader.asks(({ translate, translateMap, localeJoin, getInstanceById, }) => {
-    const getAttributeAbbreviation = (id) => translateMap(getInstanceById("Attribute", id)?.translations)?.abbreviation ?? MISSING_VALUE;
+    const getAttributeAbbreviation = (id) => attributedCustomName(translateMap, getInstanceById, "race", t => t.abbreviation, "Attribute", id) ?? MISSING_VALUE;
     return {
         label: translate("Attribute Adjustments"),
         value: [
@@ -69,16 +70,13 @@ const renderVariantValues = (label, variants, selector, renderValue, translation
 const renderAutomaticAdvantagesOrDisadvantages = (entity, items) => Reader.asks(({ translate, translateMap, getInstanceById, localeCompare }) => items === undefined || !isNotEmpty(items)
     ? translate("none")
     : items
-        .map(item => {
-        const instanceTranslation = translateMap(getInstanceById(entity, item.id)?.translations);
-        return (instanceTranslation?.name_in_library ?? instanceTranslation?.name ?? MISSING_VALUE);
-    })
+        .map(item => attributedCustomName(translateMap, getInstanceById, "race", t => t.name_in_library ?? t.name, entity, item.id) ?? MISSING_VALUE)
         .toSorted(localeCompare)
         .join(", "));
 const renderCommonCultures = (items) => Reader.asks(({ translate, translateMap, getInstanceById, localeCompare }) => items === undefined || !isNotEmpty(items)
     ? translate("none")
     : items
-        .map(itemId => translateMap(getInstanceById("Culture", itemId)?.translations)?.name)
+        .map(itemId => attributedName(translateMap, getInstanceById, "race", "Culture", itemId))
         .filter(isNotNullish)
         .toSorted(localeCompare)
         .join(", "));

package/lib/entities/spell.js

@@ -11,6 +11,7 @@ import { Case } from "tsondb/schema/gen";
 import { createEntityDescriptionCreator } from "../creator.js";
 import { renderAnimalTypesSection } from "./partial/animalTypes.js";
 import { renderEnhancements } from "./partial/enhancements.js";
+import { attributedCustomName, attributedName } from "./partial/markdown.js";
 import { printAnimistPowerPrerequisites, printGeodeRitualPrerequisites, } from "./partial/prerequisites/index.js";
 import { renderCastingTime, renderFastSkillNonModifiableCastingTime, renderSlowSkillNonModifiableCastingTime, } from "./partial/rated/activatable/castingTime.js";
 import { renderMagicalActionCost, renderModifiableOneTimeCost, renderNonModifiableOneTimeCost, } from "./partial/rated/activatable/cost.js";
@@ -28,29 +29,18 @@ import { formatEnergyR, localeJoinR, responsiveR, responsiveTextR, responsiveTra
 import { appendNoteIfNeeded, getResponsiveText, ResponsiveTextSize, } from "./partial/responsiveText.js";
 import { formatTimeSpanR } from "./partial/units/timeSpan.js";
 import { MISSING_VALUE } from "./partial/unknown.js";
-const renderProperty = (id) => Reader.asks(({ translate, translateMap, getInstanceById }) => {
-    const text = (() => {
-        const staticEntry = getInstanceById("Property", id);
-        const staticEntryTranslation = translateMap(staticEntry?.translations);
-        if (staticEntryTranslation === undefined) {
-            return "";
-        }
-        return staticEntryTranslation.name;
-    })();
-    return {
-        label: translate("Property"),
-        value: text,
-    };
-});
+const renderProperty = (id) => Reader.asks(({ translate, translateMap, getInstanceById }) => ({
+    label: translate("Property"),
+    value: attributedName(translateMap, getInstanceById, "property", "Property", id) ?? "",
+}));
 const getTextForTraditions = (deps, value) => {
     const text = (() => {
         switch (value.kind) {
             case "General":
                 return deps.translate("General");
             case "Specific":
-                return value.Specific.map(trad => deps.translateMap(deps.getInstanceById("MagicalTradition", trad)?.translations))
+                return value.Specific.map(trad => attributedCustomName(deps.translateMap, deps.getInstanceById, "traditions", t => t.name_for_arcane_spellworks ?? t.name, "MagicalTradition", trad))
                     .filter(isNotNullish)
-                    .map(trad => trad.name_for_arcane_spellworks ?? trad.name)
                     .sort(deps.localeCompare)
                     .join(", ");
             default:
@@ -62,10 +52,7 @@ const getTextForTraditions = (deps, value) => {
         value: text,
     };
 };
-const getTraditionNameForArcaneSpellworksById = (id, getInstanceById, translateMap) => {
-    const translation = translateMap(getInstanceById("MagicalTradition", id)?.translations);
-    return translation?.name_for_arcane_spellworks ?? translation?.name;
-};
+const getTraditionNameForArcaneSpellworksById = (id, getInstanceById, translateMap) => attributedCustomName(translateMap, getInstanceById, "cantrip-note", t => t.name_for_arcane_spellworks ?? t.name, "MagicalTradition", id);
 /**
  * Get a JSON representation of the rules text for a cantrip.
  */
@@ -107,7 +94,7 @@ export const getCantripEntityDescription = createEntityDescriptionCreator(({ get
                                         .map(academyOrTradition => {
                                         switch (academyOrTradition.kind) {
                                             case "Academy":
-                                                return translateMap(getInstanceById("Curriculum", academyOrTradition.Academy)?.translations)?.name;
+                                                return attributedName(translateMap, getInstanceById, "cantrip-note", "Curriculum", academyOrTradition.Academy);
                                             case "Tradition": {
                                                 return mapNullable(getTraditionNameForArcaneSpellworksById(academyOrTradition.Tradition.id, getInstanceById, translateMap), name => name +
                                                     parensIf(translateMap(academyOrTradition.Tradition.translations)?.note));
@@ -296,7 +283,8 @@ export const getCurseEntityDescription = createEntityDescriptionCreator(({ getIn
 const renderMagicalActionSkill = (skill) => Reader.asks(({ translate, translateMap, localeCompare, localeJoin, getInstanceById }) => ({
     label: translate("Skill"),
     value: localeJoin(skill
-        .map(id => translateMap(getInstanceById("Skill", id)?.translations)?.name ?? MISSING_VALUE)
+        .map(id => attributedName(translateMap, getInstanceById, "magical-action-skill", "Skill", id) ??
+        MISSING_VALUE)
         .toSorted(localeCompare), "disjunction"),
 }));
 /**
@@ -383,7 +371,7 @@ export const getDominationRitualEntityDescription = createEntityDescriptionCreat
 const renderMusicTradition = (translate, translateMap, localeCompare, getInstanceById, entity, musicTraditions) => ({
     label: translate("Music Tradition"),
     value: ensureNonEmpty(musicTraditions
-        .map(trad => translateMap(getInstanceById(entity, trad.id)?.translations)?.name)
+        .map(trad => attributedName(translateMap, getInstanceById, "music-tradition", entity, trad.id))
         .filter(isNotNullish)
         .toSorted(localeCompare))?.join(", ") ?? MISSING_VALUE,
 });
@@ -472,7 +460,7 @@ export const getMagicalMelodyEntityDescription = createEntityDescriptionCreator(
 const renderFamiliarsTrickProperty = (translateMap, getInstanceById, responsiveTextSize, property) => {
     switch (property.kind) {
         case "Fixed":
-            return (translateMap(getInstanceById("Property", property.Fixed)?.translations)?.name ??
+            return (attributedName(translateMap, getInstanceById, "property", "Property", property.Fixed) ??
                 MISSING_VALUE);
         case "Indefinite":
             return getResponsiveText(translateMap(property.Indefinite.translations)?.description, responsiveTextSize);
@@ -573,7 +561,7 @@ const renderAnimistPowerTribeTradition = (translate, translateMap, localeCompare
         return translate("General");
     }
     return (ensureNonEmpty(tribeTradition
-        .map(id => translateMap(getInstanceById("Tribe", id)?.translations)?.name)
+        .map(id => attributedName(translateMap, getInstanceById, "tribe", "Tribe", id))
         .filter(isNotNullish)
         .toSorted(localeCompare))?.join(", ") ?? MISSING_VALUE);
 };