@optolith/entity-descriptions 0.2.0 → 0.3.1

package/lib/entities/partial/activatableNameChunks.js

@@ -0,0 +1,356 @@
+import { allSame } from "@elyukai/utils/array/filters";
+import { ensureNonEmpty, isNotEmpty } from "@elyukai/utils/array/nonEmpty";
+import { deepEqual } from "@elyukai/utils/equality";
+import { identity, on } from "@elyukai/utils/function";
+import { isNotNullish } from "@elyukai/utils/nullable";
+import { mapObject } from "@optolith/helpers/object";
+import { romanize } from "@optolith/helpers/roman";
+import { assertExhaustive } from "@optolith/helpers/typeSafety";
+import { MISSING_VALUE } from "./unknown.js";
+const combineChunks = (a, b, join) => {
+    if (typeof a === "string") {
+        if (typeof b === "string") {
+            return join(a, b);
+        }
+        else if (typeof b === "function") {
+            return fs => join(a, b(fs));
+        }
+        else if (typeof b === "object") {
+            return mapObject(b, bValue => join(a, bValue));
+        }
+        return b;
+    }
+    else if (typeof a === "function") {
+        if (typeof b === "string") {
+            return fs => join(a(fs), b);
+        }
+        else if (typeof b === "function") {
+            return fs => join(a(fs), b(fs));
+        }
+        else if (typeof b === "object") {
+            return translateMap => join(a(translateMap), translateMap(b) ?? MISSING_VALUE);
+        }
+        return b;
+    }
+    else if (typeof a === "object") {
+        if (typeof b === "string") {
+            return mapObject(a, aValue => join(aValue, b));
+        }
+        else if (typeof b === "function") {
+            return translateMap => join(translateMap(a) ?? MISSING_VALUE, b(translateMap));
+        }
+        else if (typeof b === "object") {
+            const ret = {};
+            for (const key of new Set([...Object.keys(a), ...Object.keys(b)])) {
+                ret[key] = join(a[key] ?? MISSING_VALUE, b[key] ?? MISSING_VALUE);
+            }
+            return ret;
+        }
+        return b;
+    }
+    return a;
+};
+const combinePair = (pair) => combineChunks(pair[0], pair[1], (a, b) => `${a}: ${b}`);
+const normalizeChunks = (chunk) => (Array.isArray(chunk) ? combinePair(chunk) : chunk);
+/**
+ * Zips multiple name chunks together, separating them with commas. Pairs of chunks are combined with a colon.
+ */
+const zipChunks = (chunks) => chunks
+    .map(normalizeChunks)
+    .reduce((acc, chunk) => acc === "" ? chunk : combineChunks(acc, chunk, (a, b) => `${a}, ${b}`), "");
+const renderLevel = (formatAsPrerequisite, id, level) => level === undefined
+    ? undefined
+    : formatAsPrerequisite ||
+        id.kind === "Advantage" ||
+        id.kind === "Disadvantage" ||
+        level === 1
+        ? romanize(level)
+        : `I–${romanize(level)}`;
+/**
+ * Converts a name chunk to a displayable string.
+ */
+const renderActivatableNameChunk = (translateMap, chunk) => {
+    if (typeof chunk === "string") {
+        return chunk;
+    }
+    else if (typeof chunk === "function") {
+        return chunk(translateMap);
+    }
+    else if (typeof chunk === "object") {
+        return translateMap(chunk) ?? MISSING_VALUE;
+    }
+    return chunk;
+};
+/**
+ * This can be used to render an activatable entry with a selectable level, as it splits the text where the level should be inserted.
+ */
+export const renderActivatableNameComponentsWithoutLevel = (translateMap, components) => {
+    const { levelPlacement, useParenthesis } = components.nameBuilderRules;
+    const wrapParens = useParenthesis
+        ? str => `(${str})`
+        : identity;
+    const base = renderActivatableNameChunk(translateMap, components.base);
+    const options = components.options === undefined
+        ? undefined
+        : wrapParens(renderActivatableNameChunk(translateMap, normalizeChunks(components.options)));
+    switch (levelPlacement.kind) {
+        case "BeforeOptions":
+            return [base, options];
+        case "AfterOptions":
+            return [[base, options].filter(isNotNullish).join(" ")];
+        default:
+            return assertExhaustive(levelPlacement);
+    }
+};
+/**
+ * Renders the name components of an activatable entry.
+ */
+export const renderActivatableNameComponents = (translateMap, components, formatAsPrerequisite) => {
+    const levelText = renderLevel(formatAsPrerequisite, components.id, components.level);
+    const [beforeLevel, afterLevel] = renderActivatableNameComponentsWithoutLevel(translateMap, components);
+    return [beforeLevel, levelText, afterLevel].filter(isNotNullish).join(" ");
+};
+/**
+ * Combines multiple name components into a single one when all values except for options are the same, joining options according to the passed function.
+ *
+ * Returns `undefined` if the components cannot be combined.
+ */
+export const combineNameComponents = (elements) => {
+    if (isNotEmpty(elements) &&
+        allSame(elements, on(item => [item.id, item.level], deepEqual))) {
+        return {
+            ...elements[0],
+            options: ensureNonEmpty(elements.map(e => e.options).filter(isNotNullish)) ?? [],
+        };
+    }
+    return undefined;
+};
+/**
+ * Renders the name components of an activatable entry, combining multiple options into one string.
+ */
+export const renderCombinedActivatableNameComponents = (translateMap, components, formatAsPrerequisite, join = list => list.join(", ")) => renderActivatableNameComponents(translateMap, {
+    ...components,
+    options: join(components.options.map(chunk => renderActivatableNameChunk(translateMap, normalizeChunks(chunk)))),
+}, formatAsPrerequisite);
+/**
+ * Renders the name components of multiple activatable entries.
+ */
+export const renderMultipleStandaloneActivatableNameComponents = (translateMap, components, formatAsPrerequisite, join = list => list.join(", ")) => join(components.map(item => renderActivatableNameComponents(translateMap, item, formatAsPrerequisite)));
+/**
+ * Renders the name components of multiple activatable entries, combining parts if possible.
+ */
+export const renderActivatableNameComponentsCombinedIfPossible = (translateMap, components, formatAsPrerequisite, join = list => list.join(", ")) => {
+    const combined = combineNameComponents(components);
+    if (combined === undefined) {
+        return renderMultipleStandaloneActivatableNameComponents(translateMap, components, formatAsPrerequisite, join);
+    }
+    else {
+        return renderCombinedActivatableNameComponents(translateMap, combined, formatAsPrerequisite, join);
+    }
+};
+// const getEntrySpecificFullName = (
+//   getInstanceById: GetInstanceById<"Aspect">,
+//   locale: LocaleEnvironment,
+//   id: ActivatableIdentifier,
+//   base: ActivatableNameChunk,
+//   level: number | undefined,
+//   printedOptions: ActivatableNameComponents["options"],
+// ):
+//   | Pick<ActivatableNameComponents, "full" | "fullWithoutLevel" | "level">
+//   | undefined => {
+//   switch (id.kind) {
+//     case "Advantage":
+// switch (id.Advantage) {
+//   case AdvantageIdentifier.HatredOf: {
+//     const [firstOption, ...rest] = printedOptions
+//     if (firstOption === undefined || Array.isArray(firstOption)) {
+//       return undefined
+//     }
+//     return combineBaseName(
+//       combineChunks(base, firstOption, (a, b) => `${a} ${b}`),
+//       level,
+//       rest,
+//     )
+//   }
+//   default:
+//     return undefined
+// }
+// case "Disadvantage":
+// switch (id.Disadvantage) {
+//   case DisadvantageIdentifier.PersonalityFlaw: {
+//     const [selection, optionalText, ...rest] = printedOptions
+//     if (
+//       selection === undefined ||
+//       Array.isArray(selection) ||
+//       Array.isArray(optionalText)
+//     ) {
+//       return undefined
+//     }
+//     return combineBaseName(base, level, [
+//       optionalText === undefined ? selection : [selection, optionalText],
+//       ...rest,
+//     ])
+//   }
+//   default:
+//     return undefined
+// }
+// case "AdvancedCombatSpecialAbility":
+// case "AdvancedKarmaSpecialAbility":
+// case "AdvancedMagicalSpecialAbility":
+// case "AdvancedSkillSpecialAbility":
+// switch (id.AdvancedSkillSpecialAbility) {
+// case AdvancedSkillSpecialAbilityIdentifier.Fachwissen: {
+//   const [skillId, firstApplicationId, secondApplicationId] = options ?? []
+// const aspect =
+//   aspectId?.tag === "Aspect"
+//     ? getAspectById(aspectId.aspect)
+//     : undefined
+// const aspectTranslations = locale.translateMap(aspect?.translations)
+// if (aspectTranslations === undefined) {
+//   return undefined
+// }
+// return combineBaseName(
+//   combineChunks(
+//     base,
+//     aspectTranslations.master_of_aspect_suffix ??
+//       aspectTranslations.name,
+//     (a, b) => `${a} ${b}`,
+//   ),
+//   level,
+//   [],
+// )
+//   const getApp = (
+//     getSid: (r: Record<ActiveObjectWithId>) => Maybe<string | number>,
+//   ) =>
+//     pipe(
+//       SA.applications,
+//       filter(pipe(AA.prerequisite, isNothing)),
+//       find(pipe(AA.id, elemF(getSid(hero_entry)))),
+//       fmap(AA.name),
+//     )
+//   return pipe_(
+//     hero_entry,
+//     AOWIA.sid,
+//     misStringM,
+//     bindF(lookupF(SDA.skills(staticData))),
+//     bindF(skill =>
+//       pipe_(
+//         List(getApp(AOWIA.sid2)(skill), getApp(AOWIA.sid3)(skill)),
+//         catMaybes,
+//         ensure(xs => flength(xs) === 2),
+//         fmap(
+//           pipe(
+//             sortStrings(staticData),
+//             formatList("conjunction")(staticData),
+//             apps => `${SA.name(skill)}: ${apps}`,
+//           ),
+//         ),
+//       ),
+//     ),
+//   )
+// }
+//   default:
+//     return undefined
+// }
+// case "AncestorGlyph":
+// case "ArcaneOrbEnchantment":
+// case "AttireEnchantment":
+// case "Beutelzauber":
+// case "BlessedTradition":
+// case "BowlEnchantment":
+// case "BrawlingSpecialAbility":
+// case "CauldronEnchantment":
+// case "CeremonialItemSpecialAbility":
+// case "ChronicleEnchantment":
+// case "CombatSpecialAbility":
+// case "CombatStyleSpecialAbility":
+// case "CommandSpecialAbility":
+// case "DaggerRitual":
+// case "FamiliarSpecialAbility":
+// case "FatePointSexSpecialAbility":
+// case "FatePointSpecialAbility":
+// case "FoolsHatEnchantment":
+//   return undefined
+// case "GeneralSpecialAbility":
+//   switch (id.GeneralSpecialAbility) {
+// case GeneralSpecialAbilityIdentifier.LanguageSpecialization: {
+//   const [languageId, specializationId] = options ?? []
+//   const language =
+//     languageId?.tag === "Language"
+//       ? getLanguageById(languageId.language)
+//       : undefined
+//   const specializations =
+//     language?.specializations?.tag === "Specific"
+//       ? language.specializations.specific.list
+//       : []
+//   const specialization =
+//     specializationId?.tag === "General"
+//       ? specializations.find(
+//           spec => spec.id === specializationId.general,
+//         )
+//       : undefined
+// if (aspectTranslations === undefined) {
+//   return undefined
+// }
+//   return pipe(
+//     SDA.specialAbilities,
+//     lookup<string>(SpecialAbilityId.Language),
+//     bindF(pipe(findSelectOption, thrush(AOWIA.sid(hero_entry)))),
+//     bindF(lang =>
+//       pipe(
+//         AOWIA.sid2,
+//         bindF(
+//           ifElse<string | number, string>(isString)<Maybe<string>>(
+//             Just,
+//           )(spec_id =>
+//             bind(SOA.specializations(lang))(subscriptF(spec_id - 1)),
+//           ),
+//         ),
+//         fmap(spec => `${SOA.name(lang)}: ${spec}`),
+//       )(hero_entry),
+//     ),
+//   )(staticData)
+// }
+const renderOptions = (displayedInProfession, getResolvedSelectOptionById, id, options) => {
+    const arr = options?.map(optionId => {
+        const optTranslations = getResolvedSelectOptionById(id, optionId)?.content
+            .translations;
+        return optTranslations === undefined
+            ? MISSING_VALUE
+            : mapObject(optTranslations, t10n => displayedInProfession
+                ? (t10n.name_in_profession ?? t10n.name)
+                : t10n.name);
+    }) ?? [];
+    if (isNotEmpty(arr) && arr.length > 1) {
+        const [first, ...rest] = arr;
+        return [first, zipChunks(rest)];
+    }
+    return arr[0];
+};
+/**
+ * Gets the name components for an activatable entry.
+ */
+export const getNameComponents = (translate, id, options, level, nameBuilderRules, translations, getBaseName, getResolvedSelectOptionById, displayedInProfession) => {
+    const nameBuilderRulesWithDefaults = {
+        levelPlacement: nameBuilderRules?.levelPlacement ?? {
+            kind: "AfterOptions",
+        },
+        useParenthesis: nameBuilderRules?.useParenthesis ?? true,
+    };
+    const renderedBase = mapObject(translations, getBaseName);
+    const renderedOptions = renderOptions(displayedInProfession, getResolvedSelectOptionById, id, options);
+    const isTradition = id.kind === "MagicalTradition" || id.kind === "BlessedTradition";
+    const actualBase = isTradition ? translate("Tradition") : renderedBase;
+    const actualOptions = isTradition
+        ? renderedOptions === undefined
+            ? renderedBase
+            : [renderedBase, normalizeChunks(renderedOptions)]
+        : renderedOptions;
+    return {
+        id,
+        base: actualBase,
+        options: actualOptions,
+        level,
+        nameBuilderRules: nameBuilderRulesWithDefaults,
+    };
+};

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

@@ -0,0 +1,9 @@
+import type { ResolvedSelectOption, ResolvedSelectOptionIdentifier } from "optolith-database-schema/cache";
+import type { ActivatableIdentifier, AdventurePointsValue } from "optolith-database-schema/gen";
+import type { GetAllInstances } from "../../helpers/getTypes.js";
+import type { LocaleEnvironment } from "../../helpers/locale.js";
+import type { BaseActivatable, BaseActivatableTranslation } from "../activatable.js";
+/**
+ * Renders an adventure points value to a human-readable string, using the provided locale for translations and formatting. For values that depend on select options or other instances, the necessary lookup functions are provided as arguments.
+ */
+export declare const renderAdventurePointsValue: (locale: LocaleEnvironment, getNameForId: (id: ActivatableIdentifier) => string | undefined, getNameForSelectOptionId: (id: ResolvedSelectOptionIdentifier) => string | undefined, getAllSelectOptions: () => ResolvedSelectOption[], getAllInstances: GetAllInstances<"Script" | "AnimalShapeSize">, value: AdventurePointsValue | number, entry: BaseActivatable, translation: BaseActivatableTranslation) => string;

package/lib/entities/partial/adventurePointsValue.js

@@ -0,0 +1,243 @@
+import { on } from "@elyukai/utils/function";
+import { unique } from "@optolith/helpers/array";
+import { deepEqual, numAsc } from "@optolith/helpers/compare";
+import { romanize } from "@optolith/helpers/roman";
+import { assertExhaustive } from "@optolith/helpers/typeSafety";
+import { evaluateMathOperation } from "./mathOperation.js";
+import { MISSING_VALUE } from "./unknown.js";
+const renderSelectOptionsAdventurePointsValue = (locale, derivedLabel, getAllSelectOptions, getNameForSelectOptionId, config) => {
+    if (config === undefined) {
+        return MISSING_VALUE;
+    }
+    switch (config.kind) {
+        case "DerivedFromImprovementCost": {
+            const start = derivedLabel();
+            return `${start}: ${locale.translate("{$value} Adventure Points", {
+                value: Array.from({ length: 4 }, (_, index) => (index + 1) * (config.DerivedFromImprovementCost.multiplier ?? 1) +
+                    (config.DerivedFromImprovementCost.offset ?? 0)).join("/"),
+            })}`;
+        }
+        case "Fixed":
+            return Map.groupBy(getAllSelectOptions().map((item) => [
+                config.Fixed.map.find(mapItem => deepEqual(mapItem.id, item.id))
+                    ?.ap_value ?? config.Fixed.default,
+                item,
+            ]), item => item[0])
+                .entries()
+                .map(([apValue, items]) => [
+                apValue,
+                locale.join(items
+                    .map(item => getNameForSelectOptionId(item[1].id))
+                    .filter(name => name !== undefined)
+                    .toSorted(locale.compare), "conjunction"),
+            ])
+                .toArray()
+                .toSorted(on(item => item[1], locale.compare))
+                .map(([apValue, itemNames]) => `${itemNames}: ${locale.translate("{$value} Adventure Points", { value: apValue })}`)
+                .join("; ");
+        default:
+            return assertExhaustive(config);
+    }
+};
+/**
+ * Renders an adventure points value to a human-readable string, using the provided locale for translations and formatting. For values that depend on select options or other instances, the necessary lookup functions are provided as arguments.
+ */
+export const renderAdventurePointsValue = (locale, getNameForId, getNameForSelectOptionId, getAllSelectOptions, getAllInstances, value, entry, translation) => {
+    const { translate, translateMap } = locale;
+    if (typeof value === "number") {
+        return translate(".input {$value :number} {{{$value} Adventure Points}}", {
+            value,
+        });
+    }
+    switch (value.kind) {
+        case "Fixed": {
+            if (entry.levels === undefined) {
+                return translate(".input {$value :number} {{{$value} Adventure Points}}", { value: value.Fixed });
+            }
+            else {
+                return translate(".input {$value :number} {{{$value} Adventure Points per level}}", { value: value.Fixed });
+            }
+        }
+        case "ByLevel": {
+            if (entry.levels !== value.ByLevel.list.length) {
+                return MISSING_VALUE;
+            }
+            const mainValue = `${translate("Level {$level}", {
+                level: Array.from({ length: entry.levels }, (_, index) => romanize(index + 1)).join("/"),
+            })}: ${value.ByLevel.list.join("/")}`;
+            const { additionalBySizeCategory } = value.ByLevel;
+            if (additionalBySizeCategory === undefined) {
+                return mainValue;
+            }
+            else {
+                const sizeCategories = [
+                    "tiny",
+                    "small",
+                    "medium",
+                    "large",
+                    "huge",
+                ];
+                const values = sizeCategories
+                    .map(sizeCategory => additionalBySizeCategory[sizeCategory])
+                    .join("/");
+                const labels = sizeCategories
+                    .map(sizeCategory => translate(sizeCategory))
+                    .join("/");
+                return `${mainValue} + ${translate("{$values} AP for size category {$labels} (per level)", { values, labels })}`;
+            }
+        }
+        case "DerivedFromSelection": {
+            const derivedSelectOptions = entry.select_options?.derived;
+            if (derivedSelectOptions === undefined) {
+                return MISSING_VALUE;
+            }
+            switch (derivedSelectOptions.kind) {
+                case "Blessings":
+                    return MISSING_VALUE;
+                case "Cantrips":
+                    return MISSING_VALUE;
+                case "TradeSecrets":
+                    return translate("depending on the trade secret");
+                case "Scripts":
+                    return translate("{$value} Adventure Points", {
+                        value: unique(getAllInstances("Script")
+                            .map(script => script.content.ap_value)
+                            .filter(apValue => apValue !== undefined))
+                            .toSorted(numAsc)
+                            .join("/"),
+                    });
+                case "AnimalShapes": {
+                    const sizes = getAllInstances("AnimalShapeSize").toSorted(on(x => x.content.ap_value, numAsc));
+                    return translate("{$values} adventure points for a {$sized} animal shape", {
+                        values: sizes.map(size => size.content.ap_value).join("/"),
+                        sized: sizes
+                            .map(size => translateMap(size.content.translations)?.name ??
+                            MISSING_VALUE)
+                            .join("/"),
+                    });
+                }
+                case "ArcaneBardTraditions":
+                    return MISSING_VALUE;
+                case "ArcaneDancerTraditions":
+                    return MISSING_VALUE;
+                case "SexPractices":
+                    return MISSING_VALUE;
+                case "Races":
+                    return MISSING_VALUE;
+                case "Cultures":
+                    return MISSING_VALUE;
+                case "RacesAndCultures":
+                    return MISSING_VALUE;
+                case "HomunculusTypes":
+                    return MISSING_VALUE;
+                case "BlessedTraditions":
+                    return MISSING_VALUE;
+                case "Elements":
+                    return MISSING_VALUE;
+                case "Properties":
+                    return MISSING_VALUE;
+                case "Aspects":
+                    return MISSING_VALUE;
+                case "Diseases":
+                    if (derivedSelectOptions.Diseases.use_half_level_as_ap_value === true) {
+                        return translate("Half the chosen disease’s level in adventure points");
+                    }
+                    else {
+                        return translate("The chosen disease’s level in adventure points");
+                    }
+                case "Poisons":
+                    if (derivedSelectOptions.Poisons.use_half_level_as_ap_value === true) {
+                        return translate("Half the chosen poison’s level in adventure points");
+                    }
+                    else {
+                        return translate("The chosen poison’s level in adventure points");
+                    }
+                case "Languages":
+                    return MISSING_VALUE;
+                case "Skills":
+                    return renderSelectOptionsAdventurePointsValue(locale, () => {
+                        switch (derivedSelectOptions.Skills.categories.length) {
+                            case 1: {
+                                const first = derivedSelectOptions.Skills.categories[0];
+                                switch (first.kind) {
+                                    case "Skills":
+                                        return translate("A/B/C/D skill");
+                                    case "Spells":
+                                        return translate("A/B/C/D spell");
+                                    case "Rituals":
+                                        return translate("A/B/C/D ritual");
+                                    case "LiturgicalChants":
+                                        return translate("A/B/C/D liturgical chant");
+                                    case "Ceremonies":
+                                        return translate("A/B/C/D ceremony");
+                                    default:
+                                        return assertExhaustive(first);
+                                }
+                            }
+                            case 2:
+                                return derivedSelectOptions.Skills.categories.every(category => category.kind === "Spells" || category.kind === "Rituals")
+                                    ? translate("A/B/C/D spellwork")
+                                    : derivedSelectOptions.Skills.categories.every(category => category.kind === "LiturgicalChants" ||
+                                        category.kind === "Ceremonies")
+                                        ? translate("A/B/C/D liturgical chant or ceremony")
+                                        : translate("A/B/C/D ability");
+                            default:
+                                return translate("A/B/C/D ability");
+                        }
+                    }, getAllSelectOptions, getNameForSelectOptionId, derivedSelectOptions.Skills.ap_value);
+                case "CombatTechniques":
+                    return renderSelectOptionsAdventurePointsValue(locale, () => translate("B/C/D combat technique"), getAllSelectOptions, getNameForSelectOptionId, derivedSelectOptions.CombatTechniques.ap_value);
+                case "TargetCategories":
+                    return MISSING_VALUE;
+                default:
+                    return assertExhaustive(derivedSelectOptions);
+            }
+        }
+        case "DependingOnActive":
+            return `${translate(".input {$value :number} {{{$value} Adventure Points}}", {
+                value: value.DependingOnActive.inactive,
+            })} (${translate(".input {$value :number} {{{$value} Adventure Points with {$name}}}", {
+                value: value.DependingOnActive.active,
+                name: getNameForId(value.DependingOnActive.id) ?? MISSING_VALUE,
+            })})`;
+        case "DependingOnActiveInstances":
+            switch (value.DependingOnActiveInstances.kind) {
+                case "Threshold":
+                    return translate(".input {$value :number} {{{$value} Adventure Points}}", {
+                        value: value.DependingOnActiveInstances.Threshold.normal,
+                    });
+                case "Expression": {
+                    const expression = value.DependingOnActiveInstances.Expression;
+                    const values = Array.from({ length: entry.maximum ?? 3 }, (_, index) => evaluateMathOperation(expression, exprValue => {
+                        switch (exprValue.kind) {
+                            case "Constant":
+                                return exprValue.Constant;
+                            case "Active":
+                                return index;
+                            default:
+                                return assertExhaustive(exprValue);
+                        }
+                    })).join("/");
+                    const labels = Array.from({ length: entry.maximum ?? 3 }, (_, index) => `${index + 1}.`).join("/");
+                    if (entry.maximum !== undefined) {
+                        return translate("{$values} Adventure Points for the {$labels} purchase", {
+                            values,
+                            labels,
+                        });
+                    }
+                    else {
+                        return translate("{$values}/and so on Adventure Points for the {$labels}/and so on purchase", {
+                            values,
+                            labels,
+                        });
+                    }
+                }
+                default:
+                    return assertExhaustive(value.DependingOnActiveInstances);
+            }
+        case "Indefinite":
+            return translation.ap_value ?? MISSING_VALUE;
+        default:
+            return assertExhaustive(value);
+    }
+};

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

@@ -0,0 +1,11 @@
+import type { AnimalType_ID } from "optolith-database-schema/gen";
+import type { GetInstanceById } from "../../helpers/getTypes.js";
+import type { LocaleCompare } from "../../helpers/locale.js";
+import type { Translate, TranslateMap } from "../../helpers/translate.js";
+/**
+ * Renders animal types an entry applies to.
+ */
+export declare const renderAnimalTypesSection: (translate: Translate, translateMap: TranslateMap, localeCompare: LocaleCompare, getInstanceById: GetInstanceById<"AnimalType">, animalTypes: AnimalType_ID[]) => {
+    label: string;
+    value: string;
+};

package/lib/entities/partial/animalTypes.js

@@ -0,0 +1,13 @@
+import { MISSING_VALUE } from "./unknown.js";
+/**
+ * Renders animal types an entry applies to.
+ */
+export const renderAnimalTypesSection = (translate, translateMap, localeCompare, getInstanceById, animalTypes) => ({
+    label: translate("Animal Types"),
+    value: animalTypes.length === 0
+        ? translate("All")
+        : animalTypes
+            .map(animalTypeId => translateMap(getInstanceById("AnimalType", animalTypeId)?.translations)?.name ?? MISSING_VALUE)
+            .toSorted(localeCompare)
+            .join(", "),
+});

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

@@ -0,0 +1,16 @@
+import type { CommonnessRatedAdvantageDisadvantage } from "optolith-database-schema/gen";
+import type { TranslationKeysWithoutParams } from "../../helpers/translate.js";
+import type { RawDefinitionListEntityDescriptionSectionItem } from "../../index.js";
+import type { StdReader } from "./reader.js";
+/**
+ * Render the names of either commonness-rated advantages or commonness-rated disadvantages.
+ */
+export declare const renderCommonnessRatedAdvantagesOrDisadvantages: <E extends "Advantage" | "Disadvantage">(entity: E, items: CommonnessRatedAdvantageDisadvantage<string>[] | undefined) => StdReader<string, "t" | "tm" | "lc" | "ibi", E>;
+/**
+ * Render the names of commonness-rated advantages and disadvantages together.
+ */
+export declare const renderCommonnessRatedAdvantagesAndDisadvantages: (advantages: CommonnessRatedAdvantageDisadvantage<string>[] | undefined, disadvantages: CommonnessRatedAdvantageDisadvantage<string>[] | undefined) => StdReader<string, "t" | "tm" | "lc" | "ibi", "Advantage" | "Disadvantage">;
+/**
+ * Render a value with a possible translation, falling back to explicity rendering the value if no translation is available.
+ */
+export declare const renderValueWithPossibleTranslation: <T>(label: TranslationKeysWithoutParams, value: T, renderValue: (value: T) => string, valueTranslation: string | undefined) => StdReader<RawDefinitionListEntityDescriptionSectionItem, "t">;