@optolith/entity-descriptions 0.13.1 → 0.14.0

package/lib/entities/profession.js

@@ -2,7 +2,7 @@ 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 { isNotNullish, isNullish, mapNullable } from "@elyukai/utils/nullable";
 import { omitKeys } from "@elyukai/utils/object";
 import { compareNumber } from "@elyukai/utils/ordering";
 import { Reader } from "@elyukai/utils/reader";
@@ -13,16 +13,13 @@ import { combineNameComponents, getNameComponents, renderActivatableNameComponen
 import { renderCommonnessRatedAdvantagesOrDisadvantages, renderValueWithPossibleTranslation, } from "./partial/commonnessRatedAdvantagesAndDisadvantages.js";
 import { attributedCustomName, attributedInstance, attributedName, attributedNameFromInstance, } from "./partial/markdown.js";
 import { printProfessionPrerequisites, printProfessionVariantPrerequisites, } from "./partial/prerequisites/index.js";
+import { renderBaseCombatTechniquesForAdventurePointsOption, renderVariantCombatTechniquesForAdventurePointsOption, } from "./partial/profession/options/combatTechniquesForAdventurePoints.js";
+import { renderBaseNumberOfSpellworksTotalingAdventurePoints, renderVariantNumberOfSpellworksTotalingAdventurePoints, } from "./partial/profession/options/numberOfSpellworksTotalingAdventurePoints.js";
+import { prepareProfessionPackages, } from "./partial/profession/packages.js";
+import { insteadOfR, renderVariantOption, renderVariantOptionPaths, } from "./partial/profession/variants.js";
 import { parensIf } from "./partial/rated/activatable/parensIf.js";
-import { attributedCustomNameR, attributedNameR, customNameR, formatR, getChildInstancesForInstanceIdFnR, getChildInstancesForInstanceIdR, getInstanceByIdR, localeCompareR, localeJoinR, localeSortR, strictNameR, translateMapFnR, translateR, translationR, } from "./partial/reader.js";
+import { attributedCustomNameR, attributedNameR, customNameR, fixedNumberOrString, formatAPValue, formatR, getChildInstancesForInstanceIdFnR, 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) => ({
-    ...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));
@@ -48,7 +45,6 @@ const renderNumericListAcrossPackages = (packages, selector, equalityFn, renderT
     .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.
  */
@@ -59,23 +55,14 @@ const plainOrInsteadOfR = (base, variant, selector, equality, render) => {
         ? 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", {
+    remove: base => translateR("no Languages and Literacy totaling {$apValue} AP", {
+        apValue: base.ap_value.toFixed(),
+    }),
+    add: override => translateR("Languages and Literacy totaling {$apValue} AP", {
+        apValue: override.ap_value.toFixed(),
+    }),
+    update: (base, override) => insteadOfR(override.ap_value, base.ap_value).then(apValue => translateR("Languages and Literacy totaling {$apValue} AP", {
         apValue,
     })),
 });
@@ -101,17 +88,17 @@ const renderSkillSpecializationOption = (option) => Reader.asks(({ format, trans
 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 firstTextR = translateR(".input {$count :number} {{{$count} of the following combat techniques {$rating}}}", { count: first.number, rating: (first.rating_modifier + 6).toFixed() });
         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,
+            rating: (other.rating_modifier + 6).toFixed(),
         })), firstTextR);
         const completeTextR = fixedTextR.then(fixedText => option.rest_rating_modifier === undefined
             ? Reader.of(fixedText)
             : translateR("{$previous}, the others {$rating}", {
                 previous: fixedText,
-                rating: option.rest_rating_modifier + 6,
+                rating: (option.rest_rating_modifier + 6).toFixed(),
             }));
         const listR = Reader.traverse(option.options, id => attributedNameR("profession", id).map(name => name ?? MISSING_VALUE))
             .thenW(list => localeSortR(list))
@@ -134,13 +121,13 @@ const renderSkillsOption = (professionPackages, skillGroup) => allSame(professio
         ? pkg.content.options.skills
         : undefined), apValue => professionPackages[0].content.options?.skills?.specific === undefined
         ? translateR("{$apValue} AP to improve other {$skillsOfGroup}", {
-            apValue,
+            apValue: fixedNumberOrString(apValue),
             skillsOfGroup: skillGroup.nameOfSkillsOfGroup,
         })
         : Reader.traverse(professionPackages[0].content.options.skills.specific, id => attributedNameR("profession", "Skill", id).map(name => name ?? MISSING_VALUE))
             .thenW(localeSortR)
-            .thenW(list => translateR("maximum SR per skill: {$maxSR}", { maxSR: 8 }).then(maxSRText => translateR("{$apValue} AP to distribute among the following skills: {$list}", {
-            apValue,
+            .thenW(list => translateR("maximum SR per skill: {$maxSR}", { maxSR: "8" }).then(maxSRText => translateR("{$apValue} AP to distribute among the following skills: {$list}", {
+            apValue: fixedNumberOrString(apValue),
             list: list.join(", ") + parensIf(maxSRText),
         })))) ?? Reader.of(undefined))
     : Reader.traverse(professionPackages, pkg => {
@@ -149,13 +136,13 @@ const renderSkillsOption = (professionPackages, skillGroup) => allSame(professio
             ? Reader.of("—")
             : skillsOption.specific === undefined
                 ? translateR("{$apValue} AP to improve other {$skillsOfGroup}", {
-                    apValue: skillsOption.ap_value,
+                    apValue: skillsOption.ap_value.toFixed(),
                     skillsOfGroup: skillGroup.nameOfSkillsOfGroup,
                 })
                 : Reader.traverse(skillsOption.specific, id => attributedNameR("profession", "Skill", id).map(name => name ?? MISSING_VALUE))
                     .thenW(localeSortR)
-                    .thenW(list => translateR("maximum SR per skill: {$maxSR}", { maxSR: 8 }).then(maxSRText => translateR("{$apValue} AP to distribute among the following skills: {$list}", {
-                    apValue: skillsOption.ap_value,
+                    .thenW(list => translateR("maximum SR per skill: {$maxSR}", { maxSR: "8" }).then(maxSRText => translateR("{$apValue} AP to distribute among the following skills: {$list}", {
+                    apValue: skillsOption.ap_value.toFixed(),
                     list: list.join(", ") + parensIf(maxSRText),
                 })));
     }).map(list => list.join(" / "));
@@ -175,10 +162,7 @@ const renderVariantCantripsOption = (baseOptions, variantOptions) => renderVaria
         }).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 })))
+            .then(replacementCount => insteadOfR(replacementCount, 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}}", {
@@ -192,10 +176,7 @@ const renderVariantCantripsOption = (baseOptions, variantOptions) => renderVaria
         })
             .then(count => translateR("{$count} from the following list", { count }))
             .map(text => `${text}: ${list}`))
-            .then(baseText => translateR("{$replacement} instead of {$base}", {
-            replacement: replacementText,
-            base: baseText,
-        }))),
+            .then(baseText => insteadOfR(replacementText, baseText))),
 });
 const renderSingleCantripsOption = (option) => renderVariantCantripsOption(undefined, { kind: "Override", Override: option });
 const renderCantripsOption = (professionPackages) => {
@@ -212,7 +193,7 @@ const renderCantripsOption = (professionPackages) => {
     }
 };
 const renderLiturgiesOption = (professionPackages) => mapNullable(getTotalingAPValues(professionPackages, pkg => pkg.content.options?.liturgies), apValue => translateR("Liturgies totaling {$apValue} AP", {
-    apValue,
+    apValue: fixedNumberOrString(apValue),
 })) ?? Reader.of(undefined);
 const renderVariantSkillSpecializationOption = (baseOptions, variantOptions) => renderVariantOptionPaths(baseOptions, variantOptions, {
     remove: (base) => {
@@ -260,8 +241,8 @@ const renderVariantCombatTechniquesOption = (baseOptions, variantOptions) => ren
     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 }),
+    remove: base => translateR("no Curses totaling {$apValue} AP", { apValue: base.ap_value.toFixed() }),
+    add: override => translateR("Curses totaling {$apValue} AP", { apValue: override.ap_value.toFixed() }),
     update: (base, override) => insteadOfR(override.ap_value, base.ap_value).then(apValue => translateR("Curses totaling {$apValue} AP", {
         apValue,
     })),
@@ -273,17 +254,17 @@ const renderVariantSkillsOption = (baseOptions, variantOptions) => renderVariant
         skillsOfGroup: nameOfSkillsOfGroup,
     })),
     add: override => nameOfSkillsOfGroupR(override.group).thenW(nameOfSkillsOfGroup => translateR("{$apValue} AP to improve other {$skillsOfGroup}", {
-        apValue: override.ap_value,
+        apValue: override.ap_value.toFixed(),
         skillsOfGroup: nameOfSkillsOfGroup,
     })),
     update: (base, override) => plainOrInsteadOfR(base, override, b => b.ap_value, equal, b => Reader.of(b)).thenW(apValue => plainOrInsteadOfR(base, override, b => b.group, equal, nameOfSkillsOfGroupR).thenW(nameOfSkillsOfGroup => translateR("{$apValue} AP to improve other {$skillsOfGroup}", {
-        apValue,
-        skillsOfGroup: nameOfSkillsOfGroup,
+        apValue: fixedNumberOrString(apValue),
+        skillsOfGroup: fixedNumberOrString(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 }),
+    remove: base => translateR("no Liturgies totaling {$apValue} AP", { apValue: base.ap_value.toFixed() }),
+    add: override => translateR("Liturgies totaling {$apValue} AP", { apValue: override.ap_value.toFixed() }),
     update: (base, override) => insteadOfR(override.ap_value, base.ap_value).then(apValue => translateR("Liturgies totaling {$apValue} AP", {
         apValue,
     })),
@@ -416,6 +397,9 @@ const renderCombatTechniques = (professionPackages) => Reader.sequence([
     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),
+    professionPackages.some(pkg => pkg.content.options?.combatTechniquesForAdventurePoints !== undefined)
+        ? renderBaseCombatTechniquesForAdventurePointsOption(professionPackages)
+        : 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
@@ -444,6 +428,9 @@ const renderSpellworkName = (spellworkIds) => Reader.traverse(spellworkIds, spel
 const renderSpellworks = (professionPackages) => Reader.sequence([
     renderCantripsOption(professionPackages),
     renderNumericListAcrossPackages(professionPackages, (pkg) => Reader.of(pkg.content.spells?.map(ct => [ct.id, ct.rating_modifier]) ?? []), deepEqual, renderSpellworkName, undefined),
+    professionPackages.some(pkg => pkg.content.options?.spellworks !== undefined)
+        ? renderBaseNumberOfSpellworksTotalingAdventurePoints(professionPackages)
+        : Reader.of(undefined),
 ]).map(list => ensureNonEmpty(list.filter(isNotNullish))?.join("; "));
 const retrieveBlessedTraditionIdentifierFromPrerequisiteGroup = (prerequisite) => prerequisite.kind === "Activatable" && prerequisite.Activatable.id.kind === "BlessedTradition"
     ? [prerequisite.Activatable.id.BlessedTradition]
@@ -533,17 +520,9 @@ const renderRatedVariantChanges = (baseList, variantList, renderInstance) => Rea
         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()}`,
-        base: baseValue,
-    }));
+    return renderInstance(id).thenW(name => insteadOfR(`${name} ${(baseValue + rating_modifier).toFixed()}`, 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, translations) => translateR("{$value} AP", {
-    value: base.ap_value + (variant.ap_value ?? 0),
-}).thenW(apValueText => localeSortR(translations.map(({ id, content }) => `^[${content.name.default}](entity: "ProfessionVariant", instance: "${id}")`))
+const renderProfessionVariantLabel = (base, variant, translations) => formatAPValue(base.ap_value + (variant.ap_value ?? 0)).thenW(apValueText => localeSortR(translations.map(({ id, content }) => `^[${content.name.default}](entity: "ProfessionVariant", instance: "${id}")`))
     .thenW(list => localeJoinR(list, "conjunction"))
     .map(names => names + parensIf(apValueText)));
 const renderProfessionVariantText = (base, variant, translation) => translation.full_text !== undefined
@@ -557,9 +536,11 @@ const renderProfessionVariantText = (base, variant, translation) => translation.
         renderVariantOption(base, variant, "skill_specialization", renderVariantSkillSpecializationOption),
         renderVariantOption(base, variant, "languages_scripts", renderVariantLanguagesScriptsOption),
         renderVariantOption(base, variant, "combat_techniques", renderVariantCombatTechniquesOption),
+        renderVariantOption(base, variant, "combatTechniquesForAdventurePoints", renderVariantCombatTechniquesForAdventurePointsOption),
         renderVariantOption(base, variant, "cantrips", renderVariantCantripsOption),
         renderVariantOption(base, variant, "curses", renderVariantCursesOption),
         renderVariantOption(base, variant, "skills", renderVariantSkillsOption),
+        renderVariantOption(base, variant, "spellworks", renderVariantNumberOfSpellworksTotalingAdventurePoints),
         renderVariantOption(base, variant, "liturgies", renderVariantLiturgiesOption),
         variant.special_abilities === undefined
             ? Reader.of([])
@@ -635,10 +616,11 @@ const renderProfessionVariants = (professionPackages) => professionPackages.leng
  * 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 { format, formatNumber, translate, translateMap, compare: localeCompare, join: localeJoin, } = locale;
     const translation = translateMap(entry.translations);
     const env = {
         format,
+        formatNumber,
         translate,
         translateMap,
         localeCompare,

package/lib/entities/spell.d.ts

@@ -12,7 +12,7 @@ export declare const getCantripEntityDescription: import("../creator.js").Entity
  * Get a JSON representation of the rules text for a skill.
  */
 export declare const getSpellEntityDescription: import("../creator.js").EntityDescriptionCreator<"Spell", {
-    getInstanceById: GetInstanceById<"Publication" | "Attribute" | "SkillModificationLevel" | "TargetCategory" | "Property" | "MagicalTradition" | "DerivedCharacteristic" | RatedIdentifier["kind"] | "Enhancement">;
+    getInstanceById: GetInstanceById<"Publication" | "Attribute" | "SkillModificationLevel" | "TargetCategory" | "Property" | "MagicalTradition" | "DerivedCharacteristic" | RatedIdentifier["kind"] | "Enhancement" | "FocusRule">;
     getChildInstancesForInstanceId: GetAllChildInstancesForParent<"Enhancement">;
     idMap: IdMap;
 }, import("../index.js").EntityDescription>;
@@ -20,7 +20,7 @@ export declare const getSpellEntityDescription: import("../creator.js").EntityDe
  * Get a JSON representation of the rules text for a ritual.
  */
 export declare const getRitualEntityDescription: import("../creator.js").EntityDescriptionCreator<"Ritual", {
-    getInstanceById: GetInstanceById<"Publication" | "Attribute" | "SkillModificationLevel" | "TargetCategory" | "Property" | "MagicalTradition" | "DerivedCharacteristic" | RatedIdentifier["kind"] | "Enhancement">;
+    getInstanceById: GetInstanceById<"Publication" | "Attribute" | "SkillModificationLevel" | "TargetCategory" | "Property" | "MagicalTradition" | "DerivedCharacteristic" | RatedIdentifier["kind"] | "Enhancement" | "FocusRule">;
     getChildInstancesForInstanceId: GetAllChildInstancesForParent<"Enhancement">;
     idMap: IdMap;
 }, import("../index.js").EntityDescription>;

package/lib/entities/spell.js

@@ -12,7 +12,7 @@ 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 { getDerivedFocusRuleBadgeFromPrerequisites, printAnimistPowerPrerequisites, printGeodeRitualPrerequisites, } from "./partial/prerequisites/index.js";
 import { renderCastingTime, renderFastSkillNonModifiableCastingTime, renderSlowSkillNonModifiableCastingTime, } from "./partial/rated/activatable/castingTime.js";
 import { renderMagicalActionCost, renderModifiableOneTimeCost, renderNonModifiableOneTimeCost, renderNonModifiableSustainedCost, renderStandaloneCostMap, } from "./partial/rated/activatable/cost.js";
 import { renderExpressionBasedDuration, renderMusicDuration, renderOneTimeDuration, renderSustainedDuration, } from "./partial/rated/activatable/duration.js";
@@ -162,6 +162,7 @@ export const getSpellEntityDescription = createEntityDescriptionCreator(({ getIn
     return {
         title: translation.name,
         className: "spell",
+        badge: mapNullable(entry.prerequisites, getDerivedFocusRuleBadgeFromPrerequisites)?.run(env),
         body: [
             {
                 type: "definitionList",
@@ -221,6 +222,7 @@ export const getRitualEntityDescription = createEntityDescriptionCreator(({ getI
     return {
         title: translation.name,
         className: "ritual",
+        badge: mapNullable(entry.prerequisites, getDerivedFocusRuleBadgeFromPrerequisites)?.run(env),
         body: [
             {
                 type: "definitionList",