@optolith/entity-descriptions 0.2.1 → 0.3.1

package/lib/entities/profession.js

@@ -0,0 +1,585 @@
+import { allSame } from "@elyukai/utils/array/filters";
+import { ensureNonEmpty, isEmpty, isNotEmpty, } from "@elyukai/utils/array/nonEmpty";
+import { deepEqual, equal } from "@elyukai/utils/equality";
+import { on } from "@elyukai/utils/function";
+import { isNotNullish, isNullish, mapNullable, nullableToArray, } from "@elyukai/utils/nullable";
+import { compareNumber } from "@elyukai/utils/ordering";
+import { Reader } from "@elyukai/utils/reader";
+import { assertExhaustive } from "@elyukai/utils/typeSafety";
+import { createEntityDescriptionCreator } from "../creator.js";
+import { combineNameComponents, getNameComponents, renderActivatableNameComponents, renderCombinedActivatableNameComponents, } from "./partial/activatableNameChunks.js";
+import { renderCommonnessRatedAdvantagesOrDisadvantages, renderValueWithPossibleTranslation, } from "./partial/commonnessRatedAdvantagesAndDisadvantages.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, 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) => ({
+    ...professionPackage,
+    experienceLevel: getInstanceById("ExperienceLevel", professionPackage.content.experience_level),
+}))
+    .filter((professionPackage) => professionPackage.experienceLevel !== undefined)
+    .toSorted(on(item => item.experienceLevel.adventure_points, compareNumber)));
+const renderNumericListAcrossPackages = (packages, selector, equalityFn, renderText, defaultValue) => packages
+    .reduce((accR, pkg, pkgIndex) => accR.map2(selector(pkg), (acc, selected) => selected.reduce((filledAcc, [values, number]) => {
+    const existing = filledAcc.findIndex(([value]) => equalityFn(value, values));
+    if (existing >= 0) {
+        filledAcc[existing][1][pkgIndex] = number + defaultValue;
+        return filledAcc;
+    }
+    else {
+        return [
+            ...filledAcc,
+            [
+                values,
+                Array(pkgIndex)
+                    .fill(defaultValue)
+                    .concat(number + defaultValue),
+            ],
+        ];
+    }
+}, acc.map(([value, numbers]) => [value, [...numbers, defaultValue]]))), Reader.of([]))
+    .thenW(list => Reader.traverse(list, ([value, numbers]) => renderText(value).map(text => `${text} ${numbers.join("/")}`)))
+    .thenW(list => localeSortR(list))
+    .map(list => ensureNonEmpty(list)?.join(", "));
+const renderSinglePackageValue = (professionPackages, selector, equalityFn, renderText) => Reader.traverse(professionPackages, selector).thenW(selected => (allSame(selected, equalityFn) ? renderText([selected[0]]) : renderText(selected)));
+const insteadOfR = (replacement, base) => translateR("{$replacement} instead of {$base}", { replacement, base });
+/**
+ * If the selected values of the base and the variant are equal, only renders the value once. Otherwise, renders both values as the variant value replacing the base value.
+ */
+const plainOrInsteadOfR = (base, variant, selector, equality, render) => {
+    const baseValue = selector(base);
+    const variantValue = selector(variant);
+    return equality(baseValue, variantValue)
+        ? render(baseValue)
+        : render(variantValue).thenW(replacement => render(baseValue).thenW(baseRendered => insteadOfR(replacement, baseRendered)));
+};
+const renderVariantOptionPaths = (base, variant, paths) => {
+    switch (variant.kind) {
+        case "Remove":
+            return base === undefined ? Reader.of(MISSING_VALUE) : paths.remove(base);
+        case "Override":
+            return base === undefined ? paths.add(variant.Override) : paths.update(base, variant.Override);
+        default:
+            return assertExhaustive(variant);
+    }
+};
+const renderVariantLanguagesScriptsOption = (baseOptions, variantOptions) => renderVariantOptionPaths(baseOptions, variantOptions, {
+    remove: base => translateR("no Languages and Literacy totaling {$apValue} AP", { apValue: base.ap_value }),
+    add: override => translateR("Languages and Literacy totaling {$apValue} AP", { apValue: override.ap_value }),
+    update: (base, override) => translateR("{$replacement} instead of {$base}", {
+        replacement: override.ap_value,
+        base: base.ap_value,
+    }).then(apValue => translateR("Languages and Literacy totaling {$apValue} AP", {
+        apValue,
+    })),
+});
+const renderLanguagesScriptsOption = (option) => renderVariantLanguagesScriptsOption(undefined, { kind: "Override", Override: option });
+const renderSkillSpecializationOption = (option) => Reader.asks(({ format, translate, translateMap, localeJoin, getInstanceById }) => {
+    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"),
+            });
+        case "Group":
+            return translate("Skill Specialization for a {$skillOfGroup}", {
+                skillOfGroup: format(translateMap(getInstanceById("SkillGroup", option.Group)?.translations)?.longName ??
+                    MISSING_VALUE, { hiddenCount: 1 }),
+            });
+        default:
+            return assertExhaustive(option);
+    }
+});
+const renderCombatTechniquesOption = (option) => isNotEmpty(option.fixed)
+    ? (() => {
+        const [first, ...others] = option.fixed;
+        const firstTextR = translateR(".input {$count :number} {{{$count} of the following combat techniques {$rating}}}", { count: first.number, rating: first.rating_modifier + 6 });
+        const fixedTextR = others.reduce((accTextR, other) => accTextR.then(accText => translateR(".input {$count :number} {{{$previous}, {$count} others {$rating}}}", {
+            count: other.number,
+            previous: accText,
+            rating: other.rating_modifier + 6,
+        })), firstTextR);
+        const completeTextR = fixedTextR.then(fixedText => option.rest_rating_modifier === undefined
+            ? Reader.of(fixedText)
+            : translateR("{$previous}, all others {$rating}", {
+                previous: fixedText,
+                rating: option.rest_rating_modifier + 6,
+            }));
+        const listR = Reader.traverse(option.options, strictNameR)
+            .thenW(list => localeSortR(list))
+            .thenW(list => localeJoinR(list, "disjunction"));
+        return completeTextR.thenW(completeText => listR.map(list => `${completeText}: ${list}`));
+    })()
+    : Reader.of(MISSING_VALUE);
+const getTotalingAPValues = (professionPackages, selector) => {
+    const options = professionPackages.map(selector);
+    if (!isNotEmpty(options) || options.every(isNullish)) {
+        return undefined;
+    }
+    return allSame(options, deepEqual)
+        ? options[0].ap_value
+        : options.map(option => option?.ap_value ?? 0).join("/");
+};
+const renderSkillsOption = (professionPackages, skillGroup) => mapNullable(getTotalingAPValues(professionPackages, pkg => pkg.content.options?.skills?.group === skillGroup.id
+    ? pkg.content.options?.skills
+    : undefined), apValue => translateR("{$apValue} AP to improve other {$skillsOfGroup}", {
+    apValue,
+    skillsOfGroup: skillGroup.nameOfSkillsOfGroup,
+})) ?? Reader.of(undefined);
+const renderCantripList = (cantripIds) => Reader.traverse(cantripIds, id => strictNameR("Cantrip", id))
+    .thenW(localeSortR)
+    .thenW(list => localeJoinR(list, "disjunction"));
+const renderVariantCantripsOption = (baseOptions, variantOptions) => renderVariantOptionPaths(baseOptions, variantOptions, {
+    remove: base => renderCantripList(base.options).thenW(list => translateR(".input {$count :number} {{{$count} cantrips}}", { count: 0 })
+        .then(count => translateR("{$count} from the following list", { count }))
+        .map(text => `${text}: ${list}`)),
+    add: override => renderCantripList(override.options).thenW(list => translateR(".input {$count :number} {{{$count} cantrips}}", { count: override.number })
+        .then(count => translateR("{$count} from the following list", { count }))
+        .map(text => `${text}: ${list}`)),
+    update: (base, override) => deepEqual(base.options, override.options)
+        ? renderCantripList(override.options).thenW(list => translateR(".input {$count :number} {{{$count} cantrips}}", {
+            count: override.number,
+        }).then(baseCount => translateR(".input {$count :number} {{{$count} cantrips}}", {
+            count: override.number,
+        })
+            .then(replacementCount => translateR("{$replacement} instead of {$base}", {
+            replacement: replacementCount,
+            base: baseCount,
+        }).then(count => translateR("{$count} from the following list", { count })))
+            .map(text => `${text}: ${list}`)))
+        : renderCantripList(override.options)
+            .thenW(list => translateR(".input {$count :number} {{{$count} cantrips}}", {
+            count: override.number,
+        })
+            .then(count => translateR("{$count} from the following list", { count }))
+            .map(text => `${text}: ${list}`))
+            .then(replacementText => renderCantripList(base.options)
+            .thenW(list => translateR(".input {$count :number} {{{$count} cantrips}}", {
+            count: base.number,
+        })
+            .then(count => translateR("{$count} from the following list", { count }))
+            .map(text => `${text}: ${list}`))
+            .then(baseText => translateR("{$replacement} instead of {$base}", {
+            replacement: replacementText,
+            base: baseText,
+        }))),
+});
+const renderSingleCantripsOption = (option) => renderVariantCantripsOption(undefined, { kind: "Override", Override: option });
+const renderCantripsOption = (professionPackages) => {
+    const cantripsOptions = professionPackages.map(pkg => pkg.content.options?.cantrips);
+    if (!isNotEmpty(cantripsOptions) || cantripsOptions.every(isNullish)) {
+        return Reader.of(undefined);
+    }
+    if (allSame(cantripsOptions, deepEqual)) {
+        return renderSingleCantripsOption(cantripsOptions[0]);
+    }
+    else {
+        return Reader.traverse(cantripsOptions, option => option === undefined ? Reader.of("—") : renderSingleCantripsOption(option)).map(list => list.join(" / "));
+    }
+};
+const renderLiturgiesOption = (professionPackages) => mapNullable(getTotalingAPValues(professionPackages, pkg => pkg.content.options?.liturgies), apValue => translateR("Liturgies totaling {$apValue} AP", {
+    apValue,
+})) ?? Reader.of(undefined);
+const renderVariantSkillSpecializationOption = (baseOptions, variantOptions) => renderVariantOptionPaths(baseOptions, variantOptions, {
+    remove: (base) => {
+        switch (base.kind) {
+            case "Specific":
+                return Reader.traverse(base.Specific.options, id => strictNameR("Skill", id))
+                    .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)
+                    .thenW(longName => formatR(longName, { hiddenCount: 1 }))
+                    .thenW(skillOfGroup => translateR("no Skill Specialization for a {$skillOfGroup}", {
+                    skillOfGroup,
+                }));
+            default:
+                return assertExhaustive(base);
+        }
+    },
+    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"));
+            return overrideSkills
+                .thenW(overrideSkillsText => baseSkills.thenW(baseSkillsText => insteadOfR(overrideSkillsText, baseSkillsText)))
+                .then(skillsText => translateR("Skill Specialization {$possibleSkills}", {
+                possibleSkills: skillsText,
+            }));
+        }
+        else {
+            return renderSkillSpecializationOption(override).then(overrideText => renderSkillSpecializationOption(base).then(baseText => insteadOfR(overrideText, baseText)));
+        }
+    },
+});
+const renderVariantCombatTechniquesOption = (baseOptions, variantOptions) => renderVariantOptionPaths(baseOptions, variantOptions, {
+    remove: base => renderCombatTechniquesOption({
+        ...base,
+        fixed: base.fixed.map(option => ({ ...option, number: 0 })),
+    }),
+    add: override => renderCombatTechniquesOption(override),
+    update: (base, override) => renderCombatTechniquesOption(override).then(overrideText => renderCombatTechniquesOption(base).then(baseText => insteadOfR(overrideText, baseText))),
+});
+const renderVariantCursesOption = (baseOptions, variantOptions) => renderVariantOptionPaths(baseOptions, variantOptions, {
+    remove: base => translateR("no Curses totaling {$apValue} AP", { apValue: base.ap_value }),
+    add: override => translateR("Curses totaling {$apValue} AP", { apValue: override.ap_value }),
+    update: (base, override) => insteadOfR(override.ap_value, base.ap_value).then(apValue => translateR("Curses totaling {$apValue} AP", {
+        apValue,
+    })),
+});
+const renderCursesOption = (option) => renderVariantCursesOption(undefined, { kind: "Override", Override: option });
+const nameOfSkillsOfGroupR = (skillGroupId) => getInstanceByIdR("SkillGroup", skillGroupId)
+    .thenW(translationR)
+    .map(t => t?.longName ?? 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,
+    })),
+    add: override => nameOfSkillsOfGroupR(override.group).thenW(nameOfSkillsOfGroup => translateR("{$apValue} AP to improve other {$skillsOfGroup}", {
+        apValue: override.ap_value,
+        skillsOfGroup: nameOfSkillsOfGroup,
+    })),
+    update: (base, override) => plainOrInsteadOfR(base, override, b => b.ap_value, equal, Reader.of).thenW(apValue => plainOrInsteadOfR(base, override, b => b.group, equal, nameOfSkillsOfGroupR).thenW(nameOfSkillsOfGroup => translateR("{$apValue} AP to improve other {$skillsOfGroup}", {
+        apValue,
+        skillsOfGroup: nameOfSkillsOfGroup,
+    }))),
+});
+const renderVariantLiturgiesOption = (baseOptions, variantOptions) => renderVariantOptionPaths(baseOptions, variantOptions, {
+    remove: base => translateR("no Liturgies totaling {$apValue} AP", { apValue: base.ap_value }),
+    add: override => translateR("Liturgies totaling {$apValue} AP", { apValue: override.ap_value }),
+    update: (base, override) => insteadOfR(override.ap_value, base.ap_value).then(apValue => translateR("Liturgies totaling {$apValue} AP", {
+        apValue,
+    })),
+});
+const getSpecialAbilityNameComponents = (getInstanceById, getResolvedSelectOptionById, translate, option) => {
+    const instance = getInstanceById(option.id);
+    if (instance === undefined) {
+        return undefined;
+    }
+    return getNameComponents(translate, option.id, option.options, option.level, "nameBuilderRules" in instance ? instance.nameBuilderRules : undefined, instance.translations, t => t.name, getResolvedSelectOptionById, true);
+};
+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);
+        }
+        case "Selection": {
+            const chunks = specialAbility.Selection.options.map(option => getSpecialAbilityNameComponents(getInstanceById, getResolvedSelectOptionById, translate, option));
+            const possiblyCombined = isNotEmpty(specialAbility.Selection.options) && chunks.every(isNotNullish)
+                ? combineNameComponents(chunks)
+                : undefined;
+            if (possiblyCombined === undefined) {
+                return localeJoin(chunks.map(chunk => chunk === undefined
+                    ? MISSING_VALUE
+                    : renderActivatableNameComponents(translateMap, chunk, false)), "disjunction");
+            }
+            else {
+                return renderCombinedActivatableNameComponents(translateMap, possiblyCombined, false, list => localeJoin(list, "disjunction"));
+            }
+        }
+        default:
+            return assertExhaustive(specialAbility);
+    }
+});
+const renderSpecialAbilities = (specialAbilities) => Reader.sequence([
+    specialAbilities.languagesScripts === undefined
+        ? Reader.of(undefined)
+        : renderLanguagesScriptsOption(specialAbilities.languagesScripts),
+    specialAbilities.curses === undefined
+        ? Reader.of(undefined)
+        : renderCursesOption(specialAbilities.curses),
+    specialAbilities.skillSpecialization === undefined
+        ? Reader.of(undefined)
+        : renderSkillSpecializationOption(specialAbilities.skillSpecialization),
+    specialAbilities.list === undefined
+        ? Reader.of(undefined)
+        : Reader.traverse(specialAbilities.list, renderSpecialAbilityName)
+            .thenW(localeSortR)
+            .map(ensureNonEmpty),
+]).then(rendered => {
+    const result = ensureNonEmpty(rendered.filter(isNotNullish).flat())?.join(", ");
+    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),
+    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),
+]).map(list => ensureNonEmpty(list.filter(isNotNullish))?.join(", ") ?? "—");
+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),
+    renderSkillsOption(professionPackages, {
+        id: groupId,
+        nameOfSkillsOfGroup: groupTranslation?.longName ?? MISSING_VALUE,
+    }),
+]).map(value => ({
+    label: groupTranslation?.name ?? MISSING_VALUE,
+    value: ensureNonEmpty(value.filter(isNotNullish))?.join(", ") ?? "—",
+})))));
+const renderSpellworkName = (spellworkIds) => Reader.traverse(spellworkIds, spellworkId => {
+    switch (spellworkId.kind) {
+        case "Spellwork":
+            return strictNameR(spellworkId.Spellwork.id).thenW(baseName => (spellworkId.Spellwork.tradition === undefined
+                ? Reader.of(undefined)
+                : nameR("MagicalTradition", spellworkId.Spellwork.tradition)).map(traditionName => baseName + parensIf(traditionName)));
+        case "MagicalAction":
+            return strictNameR(spellworkId.MagicalAction.id);
+        default:
+            return spellworkId;
+    }
+}).thenW(list => localeJoinR(list, "disjunction"));
+const renderSpellworks = (professionPackages) => Reader.sequence([
+    renderCantripsOption(professionPackages),
+    renderNumericListAcrossPackages(professionPackages, (pkg) => Reader.of(pkg.content.spells?.map(ct => [ct.id, ct.rating_modifier]) ?? []), deepEqual, renderSpellworkName, 0),
+]).map(list => ensureNonEmpty(list.filter(isNotNullish))?.join("; "));
+const retrieveBlessedTraditionIdentifierFromPrerequisiteGroup = (prerequisite) => prerequisite.kind === "Activatable" && prerequisite.Activatable.id.kind === "BlessedTradition"
+    ? [prerequisite.Activatable.id.BlessedTradition]
+    : [];
+const retrieveBlessedTraditionIdentifierFromPrerequisites = (prerequisites) => prerequisites?.flatMap(part => {
+    switch (part.kind) {
+        case "Single":
+            return retrieveBlessedTraditionIdentifierFromPrerequisiteGroup(part.Single);
+        case "Disjunction":
+            return part.Disjunction.list.flatMap(retrieveBlessedTraditionIdentifierFromPrerequisiteGroup);
+        case "Group":
+            return part.Group.list.flatMap(retrieveBlessedTraditionIdentifierFromPrerequisiteGroup);
+        default:
+            return assertExhaustive(part);
+    }
+}) ?? [];
+const renderBlessingList = (blessings) => Reader.traverse(blessings, id => strictNameR("Blessing", id)).thenW(localeSortR);
+const renderRestrictedBlessings = (restrictedBlessings) => {
+    switch (restrictedBlessings.kind) {
+        case "Three":
+            return renderBlessingList(restrictedBlessings.Three);
+        case "Six":
+            return renderBlessingList(restrictedBlessings.Six);
+        default:
+            return assertExhaustive(restrictedBlessings);
+    }
+};
+const renderSingleBlessings = (traditions) => Reader.traverse(traditions, traditionId => getInstanceByIdR("BlessedTradition", traditionId).map(tradition => tradition?.restricted_blessings)).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))));
+        })()
+        : 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));
+    if (traditions.every(isEmpty)) {
+        return Reader.of(undefined);
+    }
+    else if (allSame(traditions, deepEqual)) {
+        return renderSingleBlessings(traditions[0]);
+    }
+    else {
+        return Reader.traverse(traditions, option => option === undefined ? Reader.of("—") : renderSingleBlessings(option)).map(list => list.join(" / "));
+    }
+};
+const renderLiturgicalChantName = (liturgyIds) => Reader.traverse(liturgyIds, strictNameR).thenW(list => localeJoinR(list, "disjunction"));
+const renderLiturgicalChants = (professionPackages) => Reader.sequence([
+    renderBlessings(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 renderRatedVariantChanges = (baseList, variantList, renderInstance) => Reader.traverse(variantList ?? [], ({ id, rating_modifier }) => {
+    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}`,
+        base: baseValue,
+    }));
+}).thenW(localeSortR);
+const renderVariantOption = (base, variant, key, render) => (variant.options?.[key] === undefined
+    ? Reader.of(undefined)
+    : render(base.options?.[key], variant.options[key])).map(text => nullableToArray(text));
+const renderProfessionVariantLabel = (base, variant, translation) => translateR("{$value} AP", {
+    value: base.ap_value + (variant.ap_value ?? 0),
+}).map(apValueText => translation.name.default + parensIf(apValueText));
+const renderProfessionVariantText = (base, variant, translation) => translation.full_text !== undefined
+    ? Reader.of(translation.full_text)
+    : Reader.sequence([
+        Reader.asks(env => variant.prerequisites === undefined
+            ? []
+            : [
+                printProfessionPrerequisites(env.getInstanceById, env.getResolvedSelectOptionById, {
+                    ...env,
+                    join: env.localeJoin,
+                    compare: env.localeCompare,
+                }, variant.prerequisites),
+            ]),
+        renderVariantOption(base, variant, "skill_specialization", renderVariantSkillSpecializationOption),
+        renderVariantOption(base, variant, "languages_scripts", renderVariantLanguagesScriptsOption),
+        renderVariantOption(base, variant, "combat_techniques", renderVariantCombatTechniquesOption),
+        renderVariantOption(base, variant, "cantrips", renderVariantCantripsOption),
+        renderVariantOption(base, variant, "curses", renderVariantCursesOption),
+        renderVariantOption(base, variant, "skills", renderVariantSkillsOption),
+        renderVariantOption(base, variant, "liturgies", renderVariantLiturgiesOption),
+        variant.special_abilities === undefined
+            ? Reader.of([])
+            : Reader.traverse(variant.special_abilities, specialAbility => {
+                switch (specialAbility.action.kind) {
+                    case "Remove":
+                        return translateR("no special ability").thenW(prefix => renderSpecialAbilityName(specialAbility.value).map(name => `${prefix} ${name}`));
+                    case "Override":
+                        return renderSpecialAbilityName(specialAbility.value);
+                    default:
+                        return assertExhaustive(specialAbility.action);
+                }
+            }),
+        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),
+    ]).map(lists => lists
+        .filter(isNotEmpty)
+        .map(list => list.join(", "))
+        .join("; ") + (translation.concluding_text ?? ""));
+const renderProfessionVariant = (base, variant) => translationR(variant).thenW(translation => translation === undefined
+    ? Reader.of(undefined)
+    : renderProfessionVariantLabel(base, variant, translation).thenW(label => renderProfessionVariantText(base, variant, translation).map((value) => ({
+        label,
+        value,
+    }))));
+const renderProfessionVariants = (professionPackages) => professionPackages.length > 1
+    ? Reader.of(UNHANDLED_VALUE)
+    : getChildInstancesForInstanceIdR("ProfessionVariant", professionPackages[0].id).thenW(variants => Reader.traverse(variants, variant => renderProfessionVariant(professionPackages[0].content, variant.content))
+        .map(list => list.filter(isNotNullish))
+        .thenW(list => list.length === 0
+        ? Reader.of(undefined)
+        : localeCompareR.map((localeCompare) => [
+            {
+                type: "definitionList",
+                style: "nested",
+                items: list.toSorted(on(item => item.label, localeCompare)),
+            },
+        ])));
+/**
+ * Get a JSON representation of the rules text for a profession version.
+ */
+export const getProfessionVersionEntityDescription = createEntityDescriptionCreator(({ getInstanceById, getAllInstances, getChildInstancesForInstanceId, getResolvedSelectOptionById, }, locale, { id, content: entry }) => {
+    const { format, translate, translateMap, compare: localeCompare, join: localeJoin } = locale;
+    const translation = translateMap(entry.translations);
+    const env = {
+        format,
+        translate,
+        translateMap,
+        localeCompare,
+        localeJoin,
+        getInstanceById,
+        getAllInstances,
+        getChildInstancesForInstanceId,
+        getResolvedSelectOptionById,
+    };
+    const professionPackages = prepareProfessionPackages(id).run(env);
+    if (translation === undefined || !isNotEmpty(professionPackages)) {
+        return undefined;
+    }
+    return {
+        title: translation.name.default +
+            (professionPackages.length > 1
+                ? ` (${professionPackages.map(pkg => translateMap(pkg.experienceLevel.translations)?.name).join("/")})`
+                : ""),
+        className: "profession",
+        body: [
+            {
+                type: "definitionList",
+                items: [
+                    {
+                        label: translate("AP Value"),
+                        value: renderSinglePackageValue(professionPackages, pkg => Reader.of(pkg.content.ap_value), equal, apValues => apValues.length === 1
+                            ? translateR(".input {$value :number} {{{$value} Adventure Points}}", {
+                                value: apValues[0],
+                            })
+                            : translateR("{$value} Adventure Points", {
+                                value: apValues.join("/"),
+                            })).run(env),
+                    },
+                    {
+                        label: translate("Prerequisites"),
+                        value: renderSinglePackageValue(professionPackages, pkg => Reader.of(pkg.content.prerequisites), deepEqual, prerequisitesLists => Reader.of(prerequisitesLists
+                            .map(prerequisites => prerequisites === undefined
+                            ? translate("none")
+                            : printProfessionPrerequisites(getInstanceById, getResolvedSelectOptionById, locale, prerequisites))
+                            .join(" / "))).run(env),
+                    },
+                    {
+                        label: translate("Special Abilities"),
+                        value: renderSinglePackageValue(professionPackages, pkg => Reader.of({
+                            skillSpecialization: pkg.content.options?.skill_specialization,
+                            languagesScripts: pkg.content.options?.languages_scripts,
+                            curses: pkg.content.options?.curses,
+                            list: pkg.content.special_abilities,
+                        }), deepEqual, specialAbilityLists => Reader.of(specialAbilityLists
+                            .map(specialAbilities => specialAbilities === undefined
+                            ? translate("none")
+                            : renderSpecialAbilities(specialAbilities).run(env))
+                            .join(" / "))).run(env),
+                    },
+                    {
+                        label: translate("Combat Techniques"),
+                        value: renderCombatTechniques(professionPackages).run(env),
+                    },
+                    {
+                        label: translate("Skills"),
+                        value: [
+                            {
+                                type: "definitionList",
+                                style: "nested",
+                                items: renderSkills(professionPackages).run(env),
+                            },
+                        ],
+                    },
+                    renderSpellworks(professionPackages)
+                        .map(value => value === undefined
+                        ? undefined
+                        : {
+                            label: translate("Spellworks"),
+                            value,
+                        })
+                        .run(env),
+                    renderLiturgicalChants(professionPackages)
+                        .map(value => value === undefined
+                        ? undefined
+                        : {
+                            label: translate("Liturgical Chants"),
+                            value,
+                        })
+                        .run(env),
+                    renderValueWithPossibleTranslation("Suggested Advantages", entry.suggested_advantages, values => renderCommonnessRatedAdvantagesOrDisadvantages("Advantage", values).run(env), translation.suggested_advantages).run(env),
+                    renderValueWithPossibleTranslation("Suggested Disadvantages", entry.suggested_disadvantages, values => renderCommonnessRatedAdvantagesOrDisadvantages("Disadvantage", values).run(env), translation.suggested_disadvantages).run(env),
+                    renderValueWithPossibleTranslation("Unsuitable Advantages", entry.unsuitable_advantages, values => renderCommonnessRatedAdvantagesOrDisadvantages("Advantage", values).run(env), translation.unsuitable_advantages).run(env),
+                    renderValueWithPossibleTranslation("Unsuitable Disadvantages", entry.unsuitable_disadvantages, values => renderCommonnessRatedAdvantagesOrDisadvantages("Disadvantage", values).run(env), translation.unsuitable_disadvantages).run(env),
+                    renderProfessionVariants(professionPackages)
+                        .map(value => value === undefined
+                        ? undefined
+                        : {
+                            label: translate("Variants"),
+                            value,
+                        })
+                        .run(env),
+                ],
+            },
+        ],
+        errata: translation.errata,
+        references: entry.src,
+    };
+});

package/lib/entities/race.d.ts

@@ -0,0 +1,9 @@
+import type { CountInstances, GetAllChildInstancesForParent, GetInstanceById } from "../helpers/getTypes.js";
+/**
+ * Get a JSON representation of the rules text for a race.
+ */
+export declare const getRaceEntityDescription: import("../creator.js").EntityDescriptionCreator<"Race", {
+    getInstanceById: GetInstanceById<"Publication" | "Attribute" | "Advantage" | "Disadvantage" | "Culture">;
+    countInstances: CountInstances<"Attribute">;
+    getChildInstancesForInstanceId: GetAllChildInstancesForParent<"RaceVariant">;
+}, import("../index.js").EntityDescription>;