@optolith/entity-descriptions 0.3.2 → 0.4.1

package/CHANGELOG.md

@@ -2,6 +2,42 @@
 
 All notable changes to this project will be documented in this file. See [commit-and-tag-version](https://github.com/absolute-version/commit-and-tag-version) for commit guidelines.
 
+## [0.4.1](https://github.com/Optolith/entity-descriptions/compare/v0.4.0...v0.4.1) (2026-03-13)
+
+
+### Features
+
+* apply map style ([414685f](https://github.com/Optolith/entity-descriptions/commit/414685f574e9669943f700564d36a27bd3711ddb))
+* focus rule badge ([c76c4cd](https://github.com/Optolith/entity-descriptions/commit/c76c4cd0c33e0187b080f7a8afb04a99cad6785c))
+* interval style time span as unit ([0c772d1](https://github.com/Optolith/entity-descriptions/commit/0c772d1cc2d65bd97804fe5a96137f4f1a601a02))
+* use more compact diff for activatable skill parameters ([70d7082](https://github.com/Optolith/entity-descriptions/commit/70d70823c24f81a47dbb8f7ced23819464926067))
+
+
+### Bug Fixes
+
+* do not use typographic formatter for multi-word cost ([fecbae5](https://github.com/Optolith/entity-descriptions/commit/fecbae5bbbccebc45660dbbb6121c8169fce1747))
+* do not wrap maximum duration if replaced ([bac8a49](https://github.com/Optolith/entity-descriptions/commit/bac8a493b2a6d5cf08ab9d461e7f84f8c83c1788))
+* min/max wrapping ([9a435e2](https://github.com/Optolith/entity-descriptions/commit/9a435e25979dea9810332c51a763e093ea403dfb))
+* missing profession specification in title ([2a97e7e](https://github.com/Optolith/entity-descriptions/commit/2a97e7e1f5b8d91a8ed27ac3545c1691d0217aa1))
+* use abbreviated attribute name in prerequisites ([1b2d21b](https://github.com/Optolith/entity-descriptions/commit/1b2d21ba68964ad7dfb542d249842cbc9bea5fa7))
+* use duration level translation if present ([a7790d6](https://github.com/Optolith/entity-descriptions/commit/a7790d68f68fc5762a954c1703a7f6b4fb3dfe07))
+
+## [0.4.0](https://github.com/Optolith/entity-descriptions/compare/v0.3.2...v0.4.0) (2026-03-12)
+
+
+### ⚠ BREAKING CHANGES
+
+* require external date formatter
+
+### Features
+
+* export helpful values and types ([5e73ce0](https://github.com/Optolith/entity-descriptions/commit/5e73ce0cb8098df2919694c72c835134bf520aea))
+
+
+### Bug Fixes
+
+* require external date formatter ([9cdf694](https://github.com/Optolith/entity-descriptions/commit/9cdf69443781203c86256dea85918960b1f17c9c))
+
 ## [0.3.2](https://github.com/Optolith/entity-descriptions/compare/v0.3.1...v0.3.2) (2026-03-12)
 
 

package/lib/creator.d.ts

@@ -1,7 +1,7 @@
 import type { EntityMap } from "optolith-database-schema/gen";
 import type { GetInstanceById } from "./helpers/getTypes.js";
-import { LocaleEnvironment } from "./helpers/locale.js";
-import { EntityDescription, RawEntityDescription } from "./index.js";
+import type { LocaleEnvironment } from "./helpers/locale.js";
+import type { EntityDescription, RawEntityDescription } from "./index.js";
 /**
  * A union type of entities with their names as a discriminant property.
  */

package/lib/creator.js

@@ -62,7 +62,7 @@ export const createEntityDescriptionCreator = (fn) => (databaseAccessors, locale
         ...rawEntry,
         body: rawEntry.body.filter(isNotNullish).map(mapRawSection),
         errata: rawEntry.errata?.map(({ date, description }) => ({
-            date: date.toLocaleDateString(locale.id),
+            date: locale.formatDate(date),
             description: description.trim(),
         })),
         references: rawEntry.references === undefined

package/lib/entities/activatable.js

@@ -20,7 +20,8 @@ const renderPropertyValue = (getInstanceById, translate, translateMap, propertyD
         case "DependingOnSelection":
             return translate("As chosen");
         case "Fixed":
-            return (translateMap(getInstanceById("Property", propertyDecl.Fixed)?.translations)?.name ?? MISSING_VALUE);
+            return (translateMap(getInstanceById("Property", propertyDecl.Fixed)?.translations)?.name ??
+                MISSING_VALUE);
         default:
             return assertExhaustive(propertyDecl);
     }
@@ -40,20 +41,14 @@ const renderPenaltyValue = (getInstanceById, translate, translateMap, name, pena
     switch (penalty.kind) {
         case "Single":
             return (sign(penalty.Single.value) +
-                (penalty.Single.applies_to_parry === true
-                    ? ` (${translate("for parry")})`
-                    : ""));
+                (penalty.Single.applies_to_parry === true ? ` (${translate("for parry")})` : ""));
         case "ByHandedness": {
-            const appendParry = penalty.ByHandedness.applies_to_parry === true
-                ? `; ${translate("for parry")}`
-                : "";
+            const appendParry = penalty.ByHandedness.applies_to_parry === true ? `; ${translate("for parry")}` : "";
             return `${sign(penalty.ByHandedness.one_handed)} (${translate("one-handed weapon") + appendParry}); ${sign(penalty.ByHandedness.two_handed)} (${translate("two-handed weapon") + appendParry})`;
         }
         case "ByActivation": {
             return `${sign(penalty.ByActivation.active)}/${sign(penalty.ByActivation.inactive)} (${[
-                penalty.ByActivation.applies_to_parry === true
-                    ? translate("for parry")
-                    : undefined,
+                penalty.ByActivation.applies_to_parry === true ? translate("for parry") : undefined,
                 translate("for secondary fighters with/without special ability {$name}", { name }),
             ]
                 .filter(isNotNullish)
@@ -62,9 +57,7 @@ const renderPenaltyValue = (getInstanceById, translate, translateMap, name, pena
         case "Selection":
             switch (penalty.Selection.options.kind) {
                 case "Specific":
-                    return penalty.Selection.options.Specific.list
-                        .map(option => sign(option.value))
-                        .join("/");
+                    return penalty.Selection.options.Specific.list.map(option => sign(option.value)).join("/");
                 case "Range":
                     return translate("{$start} to {$end}", {
                         start: sign(penalty.Selection.options.Range.minimum),
@@ -81,8 +74,8 @@ const renderPenaltyValue = (getInstanceById, translate, translateMap, name, pena
             if (external === undefined) {
                 return main;
             }
-            const externalName = translateMap(getInstanceById(external.kind, fromUniformCase(external))
-                ?.translations)?.name ?? MISSING_VALUE;
+            const externalName = translateMap(getInstanceById(external.kind, fromUniformCase(external))?.translations)
+                ?.name ?? MISSING_VALUE;
             return `${main} (${translate("depending on the level of the special ability {$name}", {
                 name: externalName,
             })})`;
@@ -90,7 +83,7 @@ const renderPenaltyValue = (getInstanceById, translate, translateMap, name, pena
         case "ByAttack": {
             const offset = penalty.ByAttack.initial_order ?? 1;
             return penalty.ByAttack.list
-                .map((penaltyByAttack, index) => `${penaltyByAttack.value} (${renderPenaltyByAttackLabel(translate, penalty.ByAttack.attack_replacement, index + offset)})`)
+                .map((penaltyByAttack, index) => `${penaltyByAttack.value.toFixed()} (${renderPenaltyByAttackLabel(translate, penalty.ByAttack.attack_replacement, index + offset)})`)
                 .join("; ");
         }
         case "DependsOnHitZone":
@@ -135,18 +128,13 @@ const wrapInParens = (args, append = "") => {
     }
     return ` (${filteredArgs.join(", ") + append})`;
 };
-const addSpaceIfNoCommaAtStart = (str) => str.startsWith(",") ? str : ` ${str}`;
+const addSpaceIfNoCommaAtStart = (str) => (str.startsWith(",") ? str : ` ${str}`);
 const renderApplicableCombatTechniquesRestriction = (getInstanceById, locale, main, restriction, translation, weapons, getExcludedInstance) => {
     switch (restriction.kind) {
         case "Improvised":
-            return (main +
-                wrapInParens([locale.translate("only improvised weapons"), weapons]));
+            return main + wrapInParens([locale.translate("only improvised weapons"), weapons]);
         case "PointedBlade":
-            return (main +
-                wrapInParens([
-                    locale.translate("weapon must have a pointed blade"),
-                    weapons,
-                ]));
+            return main + wrapInParens([locale.translate("weapon must have a pointed blade"), weapons]);
         case "Mount":
             if (weapons === undefined) {
                 return `${main} ${locale.translate("while mounted")}`;
@@ -183,23 +171,15 @@ const renderApplicableCombatTechniquesRestriction = (getInstanceById, locale, ma
                 addSpaceIfNoCommaAtStart(locale.translate("that may be performed with one-handed weapons")) +
                 wrapInParens([weapons]));
         case "TwoHanded":
-            return (locale.translate("All Two-Handed Weapons") + wrapInParens([weapons]));
+            return locale.translate("All Two-Handed Weapons") + wrapInParens([weapons]);
         case "ParryingWeapon":
             return locale.translate("All Parrying Weapons") + wrapInParens([weapons]);
         case "Level": {
-            const nameWithLevel = `${translation} ${romanize(restriction.Level.level)}`;
-            return (main +
-                wrapInParens([
-                    locale.translate("only {$nameWithLevel}", { nameWithLevel }),
-                    weapons,
-                ]));
+            const nameWithLevel = `${translation.name_in_library ?? translation.name} ${romanize(restriction.Level.level)}`;
+            return (main + wrapInParens([locale.translate("only {$nameWithLevel}", { nameWithLevel }), weapons]));
         }
         case "OneBluntSide":
-            return (main +
-                wrapInParens([
-                    locale.translate("only those with at least one blunt side"),
-                    weapons,
-                ]));
+            return (main + wrapInParens([locale.translate("only those with at least one blunt side"), weapons]));
         default:
             return assertExhaustive(restriction);
     }
@@ -242,8 +222,8 @@ const renderApplicableCombatTechniquesValue = (getInstanceById, locale, translat
                         ? undefined
                         : locale.translate("only {$weapons}", {
                             weapons: locale.join(specific.weapons
-                                .map(weapon => locale.translateMap(getInstanceById("Weapon", weapon)
-                                ?.translations)?.name ?? MISSING_VALUE)
+                                .map(weapon => locale.translateMap(getInstanceById("Weapon", weapon)?.translations)
+                                ?.name ?? MISSING_VALUE)
                                 .toSorted(locale.compare), "conjunction"),
                         }), undefined);
                 return mainWithRestriction;
@@ -272,9 +252,7 @@ const renderVolumeValue = (translate, translateMap, getAllResolvedSelectOptions,
         case "ByLevel":
             return translate("{$points} points for levels {$levels}", {
                 points: volume.ByLevel.list.map(item => item.points).join("/"),
-                levels: volume.ByLevel.list
-                    .map((_, index) => romanize(index + 1))
-                    .join("/"),
+                levels: volume.ByLevel.list.map((_, index) => romanize(index + 1)).join("/"),
             });
         case "Map":
             return renderResponsiveMap(volume.Map, option => option.points, values => translate("{$points} points", { points: values })).run({
@@ -292,8 +270,7 @@ const renderVolumeValue = (translate, translateMap, getAllResolvedSelectOptions,
                 points: groups.map(group => group[0]).join("/"),
             })} ${translate("for")} ${groups
                 .map(group => group[1]
-                .map(groupItem => translateMap(groupItem.content.translations)?.name ??
-                MISSING_VALUE)
+                .map(groupItem => translateMap(groupItem.content.translations)?.name ?? MISSING_VALUE)
                 .join(", "))
                 .join(separator)}`;
         }
@@ -320,7 +297,7 @@ const renderArcaneEnergyCost = (translate, translateMap, localeJoin, responsiveT
                 if (cost.Fixed.per_level === undefined) {
                     return prev => prev(cost.Fixed.value);
                 }
-                switch (cost.Fixed.per_level?.kind) {
+                switch (cost.Fixed.per_level.kind) {
                     case "Compressed":
                         return prev => translate("{$cost} per level", { cost: prev(cost.Fixed.value) });
                     case "Verbose":
@@ -333,8 +310,7 @@ const renderArcaneEnergyCost = (translate, translateMap, localeJoin, responsiveT
                 }
             })();
             const noteInParens = parensIf(mapNullable(translateMap(cost.Fixed.translations)?.note, note => getResponsiveTextOptional(note, responsiveTextSize)));
-            return (wrapInPerLevel(value => wrapInInterval(translationWrapper(value))) +
-                noteInParens);
+            return wrapInPerLevel(value => wrapInInterval(translationWrapper(value))) + noteInParens;
         }
         case "Constant":
             return (translate("{$value} AE", { value: cost.Constant.value }) +
@@ -369,11 +345,11 @@ const renderArcaneEnergyCost = (translate, translateMap, localeJoin, responsiveT
                 interval: formatTimeSpan(translate, responsiveTextSize, cost.ActivationAndHalfInterval.interval.unit, cost.ActivationAndHalfInterval.interval.value),
             }));
         case "Indefinite":
-            return (mapNullable(translateMap(cost.Indefinite.translations)?.description, description => getResponsiveText(description, responsiveTextSize)) +
+            return ((mapNullable(translateMap(cost.Indefinite.translations)?.description, description => getResponsiveText(description, responsiveTextSize)) ?? MISSING_VALUE) +
                 mapNullableDefault(cost.Indefinite.modifier, modifier => ` + ${translate("{$value} AE", { value: modifier.value })}`, ""));
         case "Disjunction":
             return translate("{$value} AE", {
-                value: localeJoin(cost.Disjunction.options.map(option => option.value +
+                value: localeJoin(cost.Disjunction.options.map(option => option.value.toFixed() +
                     mapNullableDefault(translateMap(option.translations)?.note, note => parensIf(getResponsiveTextOptional(note, responsiveTextSize)), "")), "disjunction"),
             });
         case "Map":
@@ -382,6 +358,7 @@ const renderArcaneEnergyCost = (translate, translateMap, localeJoin, responsiveT
                     surround: values => translate(", {$value} of which are permanent", {
                         value: values,
                     }),
+                    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- is checked beforehand
                     getAdditionalValue: option => option.permanent_value,
                 }
                 : undefined).run({
@@ -442,8 +419,7 @@ const renderBindingCost = (translate, translateMap, localeCompare, getAllResolve
                 value: groups.map(group => group[0]).join("/"),
             })} ${translate("for")} ${groups
                 .map(group => group[1]
-                .map(groupItem => translateMap(groupItem.content.translations)?.name ??
-                MISSING_VALUE)
+                .map(groupItem => translateMap(groupItem.content.translations)?.name ?? MISSING_VALUE)
                 .toSorted(localeCompare)
                 .join(", "))
                 .join(separator)}`;
@@ -471,8 +447,7 @@ const renderCost = (translate, translateMap, localeJoin, localeCompare, getAllRe
                 label: translate("AE Cost"),
                 value: cost.kind === "ArcaneEnergyCost"
                     ? "ae_cost" in cost.ArcaneEnergyCost
-                        ? renderArcaneEnergyCost(translate, translateMap, localeJoin, responsiveTextSize, levels, cost.ArcaneEnergyCost.ae_cost) +
-                            renderLifePointsCost(translate, cost.ArcaneEnergyCost.lp_cost)
+                        ? renderArcaneEnergyCost(translate, translateMap, localeJoin, responsiveTextSize, levels, cost.ArcaneEnergyCost.ae_cost) + renderLifePointsCost(translate, cost.ArcaneEnergyCost.lp_cost)
                         : renderArcaneEnergyCost(translate, translateMap, localeJoin, responsiveTextSize, levels, cost.ArcaneEnergyCost)
                     : renderArcaneEnergyCost(translate, translateMap, localeJoin, responsiveTextSize, levels, cost),
             };
@@ -488,7 +463,7 @@ const renderCost = (translate, translateMap, localeJoin, localeCompare, getAllRe
 /**
  * Get a JSON representation of the rules text for a special ability.
  */
-export const getActivatableEntityDescription = createEntityDescriptionCreator(({ getInstanceById, getAllInstances, getResolvedSelectOptionById, getAllResolvedSelectOptions, }, locale, { entity: entityName, content: entry, id }) => {
+export const getActivatableEntityDescription = createEntityDescriptionCreator(({ getInstanceById, getAllInstances, getResolvedSelectOptionById, getAllResolvedSelectOptions }, locale, { entity: entityName, content: entry, id }) => {
     const { translate, translateMap } = locale;
     const translation = translateMap(entry.translations);
     const responsiveTextSize = ResponsiveTextSize.Full;
@@ -500,9 +475,7 @@ export const getActivatableEntityDescription = createEntityDescriptionCreator(({
     return {
         title: translation.name_in_library ??
             translation.name +
-                (baseEntry.levels !== undefined
-                    ? ` I–${romanize(baseEntry.levels)}`
-                    : ""),
+                (baseEntry.levels !== undefined ? ` I–${romanize(baseEntry.levels)}` : ""),
         subtitle: mapNullable(baseEntry.usage_type, usageType => {
             switch (usageType.kind) {
                 case "Passive":
@@ -546,8 +519,8 @@ export const getActivatableEntityDescription = createEntityDescriptionCreator(({
                     })),
                     mapNullable(baseEntry.aspect, aspect => ({
                         label: translate("Aspect"),
-                        value: translateMap(getInstanceById("Aspect", aspect)?.translations)
-                            ?.name ?? MISSING_VALUE,
+                        value: translateMap(getInstanceById("Aspect", aspect)?.translations)?.name ??
+                            MISSING_VALUE,
                     })),
                     mapNullable(translation.range, range => ({
                         label: translate("Range"),
@@ -559,8 +532,7 @@ export const getActivatableEntityDescription = createEntityDescriptionCreator(({
                     })),
                     mapNullable(entry.prerequisites, prerequisites => ({
                         label: translate("Prerequisites"),
-                        value: wrappedId.kind === "Advantage" ||
-                            wrappedId.kind === "Disadvantage"
+                        value: wrappedId.kind === "Advantage" || wrappedId.kind === "Disadvantage"
                             ? printAdvantageDisadvantagePrerequisites(getInstanceById, getResolvedSelectOptionById, locale, prerequisites, translation.name, wrappedId.kind)
                             : printGeneralPrerequisites(getInstanceById, getResolvedSelectOptionById, locale, prerequisites, mapNullable(baseEntry.levels, levels => ({
                                 id: wrappedId,
@@ -581,12 +553,11 @@ export const getActivatableEntityDescription = createEntityDescriptionCreator(({
                         value: renderPropertyValue(getInstanceById, translate, translateMap, property),
                     })),
                     mapNullable(entry.ap_value, apValue => {
-                        const append = translation.ap_value_append !== undefined
-                            ? ` ${translation.ap_value_append}`
-                            : "";
+                        const append = translation.ap_value_append !== undefined ? ` ${translation.ap_value_append}` : "";
                         return {
                             label: translate("AP Value"),
-                            value: renderAdventurePointsValue(locale, activatableId => locale.translateMap(getInstanceById(activatableId.kind, fromUniformCase(activatableId))?.translations)?.name, selectOptionId => {
+                            value: renderAdventurePointsValue(locale, activatableId => locale.translateMap(getInstanceById(activatableId.kind, fromUniformCase(activatableId))
+                                ?.translations)?.name, selectOptionId => {
                                 const selectOption = getResolvedSelectOptionById(wrappedId, selectOptionId);
                                 if (selectOption === undefined) {
                                     return undefined;

package/lib/entities/culture.js

@@ -7,19 +7,21 @@ import { isNotNullish, mapNullable } from "@elyukai/utils/nullable";
 import { Reader } from "@elyukai/utils/reader";
 import { sign } from "@elyukai/utils/string/number";
 import { assertExhaustive } from "@elyukai/utils/typeSafety";
+import { getAdventurePointsForRatingRange } from "@optolith/adventure-points/improvement-cost";
 import { createEntityDescriptionCreator } from "../creator.js";
 import { renderCommonnessRatedAdvantagesOrDisadvantages, renderValueWithPossibleTranslation, } from "./partial/commonnessRatedAdvantagesAndDisadvantages.js";
 import { getProfessionName } from "./partial/professions.js";
 import { parensIf } from "./partial/rated/activatable/parensIf.js";
-import { translateR, } from "./partial/reader.js";
+import { translateR } from "./partial/reader.js";
 import { MISSING_VALUE } from "./partial/unknown.js";
-import { getAdventurePointsForRatingRange } from "@optolith/adventure-points/improvement-cost";
 const renderListOperation = (operation, list) => {
     switch (operation.kind) {
         case "Intersection":
             return Reader.of(list.join(", "));
         case "Difference":
-            return translateR("all but {$excludedProfessions :list type=conjunction}", { excludedProfessions: list });
+            return translateR("all but {$excludedProfessions :list type=conjunction}", {
+                excludedProfessions: list,
+            });
         default:
             return assertExhaustive(operation);
     }
@@ -49,10 +51,7 @@ const renderWeighted = (weightedVariants, getName) => {
         return Reader.of(undefined);
     }
     return Reader.asks(({ translate, localeCompare }) => {
-        const variants = ensureNonEmpty(weightedVariants.elements
-            .map(getName)
-            .filter(isNotNullish)
-            .toSorted(localeCompare));
+        const variants = ensureNonEmpty(weightedVariants.elements.map(getName).filter(isNotNullish).toSorted(localeCompare));
         if (variants === undefined) {
             return undefined;
         }
@@ -74,10 +73,9 @@ const renderProfessionConstraint = (getChildInstancesForInstanceId, constraint)
     ? Reader.of(undefined)
     : Reader.sequence([
         renderRarity(constraint.rarity),
-        Reader.asks(({ translateMap, getInstanceById, }) => renderWeighted(constraint.weighted_variants, variantId => translateMap(getInstanceById("ProfessionVariant", variantId)
-            ?.translations)?.name.default)).thenW(identity),
-    ]).map(notes => baseName +
-        parensIf(ensureNonEmpty(notes.filter(isNotNullish))?.join("; "))));
+        Reader.asks(({ translateMap, getInstanceById }) => renderWeighted(constraint.weighted_variants, variantId => translateMap(getInstanceById("ProfessionVariant", variantId)?.translations)
+            ?.name.default)).thenW(identity),
+    ]).map(notes => baseName + parensIf(ensureNonEmpty(notes.filter(isNotNullish))?.join("; "))));
 const renderTraditionConstraint = (getChildInstancesForInstanceId, entity, constraint) => Reader.asks(({ translateMap, getInstanceById }) => {
     const translation = translateMap(getInstanceById(entity, constraint.id)?.translations);
     return translation?.nameOfBlessedOnes ?? translation?.name;
@@ -86,8 +84,7 @@ const renderTraditionConstraint = (getChildInstancesForInstanceId, entity, const
     : Reader.sequence([
         renderRarity(constraint.rarity),
         Reader.asks(({ translateMap }) => renderWeighted(constraint.weighted_professions, profId => getProfessionName(translateMap, getChildInstancesForInstanceId, profId))).thenW(identity),
-    ]).map(notes => baseName +
-        parensIf(ensureNonEmpty(notes.filter(isNotNullish))?.join("; "))));
+    ]).map(notes => baseName + parensIf(ensureNonEmpty(notes.filter(isNotNullish))?.join("; "))));
 const renderCommonProfessions = (getChildInstancesForInstanceId, commonProfessions) => {
     switch (commonProfessions.kind) {
         case "Plain":
@@ -121,8 +118,7 @@ const renderCommonProfessions = (getChildInstancesForInstanceId, commonProfessio
 const renderCommonSkills = (items) => Reader.asks(({ translate, translateMap, getInstanceById, localeCompare }) => items === undefined || !isNotEmpty(items)
     ? translate("none")
     : items
-        .map(itemId => translateMap(getInstanceById("Skill", itemId)?.translations)
-        ?.name)
+        .map(itemId => translateMap(getInstanceById("Skill", itemId)?.translations)?.name)
         .filter(isNotNullish)
         .toSorted(localeCompare)
         .join(", "));
@@ -161,7 +157,7 @@ const renderCulturalPackage = (items) => Reader.asks(({ translate, translateMap,
             return [MISSING_VALUE, 0];
         }
         return [
-            `${instanceTranslation.name ?? MISSING_VALUE} ${sign(item.points)}`,
+            `${instanceTranslation.name} ${sign(item.points)}`,
             getAdventurePointsForRatingRange(instance.improvement_cost.kind, 0, item.points),
         ];
     });
@@ -201,8 +197,7 @@ export const getCultureEntityDescription = createEntityDescriptionCreator(({ get
                             .map(lang => {
                             const language = getInstanceById("Language", lang.id);
                             const languageTranslation = translateMap(language?.translations);
-                            if (language === undefined ||
-                                languageTranslation === undefined) {
+                            if (language === undefined || languageTranslation === undefined) {
                                 return MISSING_VALUE;
                             }
                             return (languageTranslation.name +
@@ -224,8 +219,7 @@ export const getCultureEntityDescription = createEntityDescriptionCreator(({ get
                                 const processedScripts = entry.script.map((scriptId) => {
                                     const script = getInstanceById("Script", scriptId);
                                     const scriptTranslation = translateMap(script?.translations);
-                                    if (script === undefined ||
-                                        scriptTranslation === undefined) {
+                                    if (script === undefined || scriptTranslation === undefined) {
                                         return [MISSING_VALUE, 0];
                                     }
                                     return [scriptTranslation.name, script.ap_value ?? 0];
@@ -234,9 +228,7 @@ export const getCultureEntityDescription = createEntityDescriptionCreator(({ get
                                     return translate("none");
                                 }
                                 if (allSame(processedScripts, on(([, apValue]) => apValue, equal))) {
-                                    return (localeJoin(processedScripts
-                                        .map(([name]) => name)
-                                        .toSorted(localeCompare), "disjunction") +
+                                    return (localeJoin(processedScripts.map(([name]) => name).toSorted(localeCompare), "disjunction") +
                                         parensIf(translate("{$value} AP", {
                                             value: processedScripts[0][1],
                                         })));
@@ -265,7 +257,8 @@ export const getCultureEntityDescription = createEntityDescriptionCreator(({ get
                     {
                         label: translate("Social Status"),
                         value: entry.social_status
-                            .map(status => translateMap(getInstanceById("SocialStatus", status)?.translations)?.name ?? MISSING_VALUE)
+                            .map(status => translateMap(getInstanceById("SocialStatus", status)?.translations)?.name ??
+                            MISSING_VALUE)
                             .toSorted(localeCompare)
                             .join(", "),
                     },
@@ -295,8 +288,7 @@ export const getCultureEntityDescription = createEntityDescriptionCreator(({ get
                 type: "labeled",
                 label: translate("Cultural Package {$cultureName}", {
                     cultureName: translation.name,
-                }) +
-                    parensIf(translate("{$value} AP", { value: culturalPackageApValue })),
+                }) + parensIf(translate("{$value} AP", { value: culturalPackageApValue })),
                 value: {
                     type: "plain",
                     text: culturePackageText,

package/lib/entities/curriculum.js

@@ -19,8 +19,8 @@ const renderElectiveSpellworks = (translate, translateMap, localeCompare, getIns
                     return name;
                 }
                 return (name +
-                    parensIf(translateMap(getInstanceById("Element", item.restriction.Element)
-                        ?.translations)?.name ?? MISSING_VALUE));
+                    parensIf(translateMap(getInstanceById("Element", item.restriction.Element)?.translations)
+                        ?.name ?? MISSING_VALUE));
             }))
                 .filter(isNotNullish)
                 .toSorted(localeCompare)
@@ -32,11 +32,9 @@ const renderElectiveSpellworks = (translate, translateMap, localeCompare, getIns
 const renderRestrictedSpellworks = (translate, translateMap, localeCompare, localeJoin, getInstanceById, restrictedSpellworks) => {
     const restrictedGroups = Dictionary.groupBy(restrictedSpellworks, restriction => restriction.kind === "Spellwork"
         ? "spellwork"
-        : restriction.kind === "Property" &&
-            restriction.Property.maximum !== undefined
+        : restriction.kind === "Property" && restriction.Property.maximum !== undefined
             ? "restrictedProperty"
-            : restriction.kind === "Property" ||
-                restriction.kind === "DemonSummoning"
+            : restriction.kind === "Property" || restriction.kind === "DemonSummoning"
                 ? "property"
                 : "other");
     const addExclusion = (excludedSpellworks) => {
@@ -55,16 +53,16 @@ const renderRestrictedSpellworks = (translate, translateMap, localeCompare, loca
     };
     const restrictedProperties = restrictedGroups.get("restrictedProperty")?.map(restriction => translate(".input {$count :number} {{only {$count} additional spellworks with the Property {$property}}}", {
         count: restriction.Property.maximum,
-        property: translateMap(getInstanceById("Property", restriction.Property.id)
-            ?.translations)?.name ?? MISSING_VALUE,
+        property: translateMap(getInstanceById("Property", restriction.Property.id)?.translations)
+            ?.name ?? MISSING_VALUE,
     }) + addExclusion(restriction.Property.exclude)) ?? [];
     const propertyGroup = restrictedGroups.get("property");
     const translatedProperties = propertyGroup
         ?.map(restriction => {
         switch (restriction.kind) {
             case "Property":
-                return translateMap(getInstanceById("Property", restriction.Property.id)
-                    ?.translations)?.name;
+                return translateMap(getInstanceById("Property", restriction.Property.id)?.translations)
+                    ?.name;
             case "DemonSummoning":
                 return translate("Demon Summoning");
             default:
@@ -82,8 +80,7 @@ const renderRestrictedSpellworks = (translate, translateMap, localeCompare, loca
         : [];
     const spellworkGroup = restrictedGroups.get("spellwork");
     const translatedSpellworks = spellworkGroup
-        ?.map(restriction => translateMap(getInstanceById(restriction.Spellwork)?.translations)
-        ?.name)
+        ?.map(restriction => translateMap(getInstanceById(restriction.Spellwork)?.translations)?.name)
         .filter(isNotNullish)
         .toSorted(localeCompare) ?? [];
     const spellworks = translatedSpellworks.length > 0
@@ -104,29 +101,26 @@ const renderRestrictedSpellworks = (translate, translateMap, localeCompare, loca
                 return assertExhaustive(restriction);
         }
     }) ?? [];
-    return [
-        ...restrictedProperties,
-        ...properties,
-        ...others,
-        ...spellworks,
-    ].join("; ");
+    return [...restrictedProperties, ...properties, ...others, ...spellworks].join("; ");
 };
-const renderSpellworkAdjustment = (translateMap, getInstanceById, adjustment) => `${translateMap(getInstanceById(adjustment.id)?.translations)?.name ??
-    MISSING_VALUE} ${adjustment.points}${parensIf(adjustment.tradition === undefined
+const renderSpellworkAdjustment = (translateMap, getInstanceById, adjustment) => `${translateMap(getInstanceById(adjustment.id)?.translations)?.name ?? MISSING_VALUE} ${adjustment.points.toFixed()}${parensIf(adjustment.tradition === undefined
     ? undefined
-    : translateMap(getInstanceById("MagicalTradition", adjustment.tradition)
-        ?.translations)?.name)}`;
+    : translateMap(getInstanceById("MagicalTradition", adjustment.tradition)?.translations)?.name)}`;
 const renderAbilityAdjustmentName = (translateMap, getInstanceById, abilityAdjustment) => {
     switch (abilityAdjustment.kind) {
         case "Skill":
-            return (translateMap(getInstanceById("Skill", abilityAdjustment.Skill.id)?.translations)?.name ?? MISSING_VALUE);
+            return (translateMap(getInstanceById("Skill", abilityAdjustment.Skill.id)?.translations)?.name ??
+                MISSING_VALUE);
         case "CombatTechnique":
-            return (translateMap(getInstanceById(abilityAdjustment.CombatTechnique.id)?.translations)?.name ?? MISSING_VALUE);
+            return (translateMap(getInstanceById(abilityAdjustment.CombatTechnique.id)?.translations)?.name ??
+                MISSING_VALUE);
         case "Spellwork":
-            return ((translateMap(getInstanceById(abilityAdjustment.Spellwork.id)?.translations)?.name ?? MISSING_VALUE) +
+            return ((translateMap(getInstanceById(abilityAdjustment.Spellwork.id)?.translations)?.name ??
+                MISSING_VALUE) +
                 parensIf(abilityAdjustment.Spellwork.tradition === undefined
                     ? undefined
-                    : translateMap(getInstanceById("MagicalTradition", abilityAdjustment.Spellwork.tradition)?.translations)?.name));
+                    : translateMap(getInstanceById("MagicalTradition", abilityAdjustment.Spellwork.tradition)
+                        ?.translations)?.name));
         default:
             return assertExhaustive(abilityAdjustment);
     }
@@ -134,7 +128,8 @@ const renderAbilityAdjustmentName = (translateMap, getInstanceById, abilityAdjus
 const renderAbilityAdjustmentBaseValue = (baseProfessionPackage, abilityAdjustment) => {
     switch (abilityAdjustment.kind) {
         case "Skill":
-            return baseProfessionPackage.skills?.find(skill => skill.id === abilityAdjustment.Skill.id)?.rating_modifier;
+            return baseProfessionPackage.skills?.find(skill => skill.id === abilityAdjustment.Skill.id)
+                ?.rating_modifier;
         case "CombatTechnique":
             return baseProfessionPackage.combat_techniques?.find(skill => deepEqual(skill.id, abilityAdjustment.CombatTechnique.id))?.rating_modifier;
         case "Spellwork":
@@ -171,16 +166,17 @@ const renderAbilityAdjustmentDefaultValue = (abilityAdjustment) => {
 const renderAbilityAdjustment = (translate, translateMap, getInstanceById, baseProfessionPackage) => baseProfessionPackage === undefined
     ? abilityAdjustment => `${renderAbilityAdjustmentName(translateMap, getInstanceById, abilityAdjustment)} ${sign(renderAbilityAdjustmentModifierValue(abilityAdjustment))}`
     : abilityAdjustment => {
-        const basePoints = (renderAbilityAdjustmentBaseValue(baseProfessionPackage, abilityAdjustment) ?? 0) + renderAbilityAdjustmentDefaultValue(abilityAdjustment);
+        const basePoints = (renderAbilityAdjustmentBaseValue(baseProfessionPackage, abilityAdjustment) ?? 0) +
+            renderAbilityAdjustmentDefaultValue(abilityAdjustment);
         return translate("{$replacement} instead of {$base}", {
             base: basePoints,
-            replacement: `${renderAbilityAdjustmentName(translateMap, getInstanceById, abilityAdjustment)} ${basePoints + renderAbilityAdjustmentModifierValue(abilityAdjustment)}`,
+            replacement: `${renderAbilityAdjustmentName(translateMap, getInstanceById, abilityAdjustment)} ${(basePoints + renderAbilityAdjustmentModifierValue(abilityAdjustment)).toFixed()}`,
         });
     };
 const renderAbilityAdjustments = (translate, translateMap, localeCompare, getInstanceById, baseProfessionPackage, list) => list
-    ?.map(renderAbilityAdjustment(translate, translateMap, getInstanceById, baseProfessionPackage))
+    .map(renderAbilityAdjustment(translate, translateMap, getInstanceById, baseProfessionPackage))
     .toSorted(localeCompare)
-    .join(", ") ?? translate("none");
+    .join(", ");
 /**
  * Get a JSON representation of the rules text for a curriculum.
  */
@@ -199,7 +195,8 @@ export const getCurriculumEntityDescription = createEntityDescriptionCreator(({
                 items: [
                     {
                         label: translate("Guideline"),
-                        value: translateMap(getInstanceById("Guideline", entry.guideline)?.translations)?.name ?? MISSING_VALUE,
+                        value: translateMap(getInstanceById("Guideline", entry.guideline)?.translations)?.name ??
+                            MISSING_VALUE,
                     },
                     {
                         label: translate("Elective Spellworks Package"),
@@ -237,7 +234,7 @@ export const getCurriculumEntityDescription = createEntityDescriptionCreator(({
                         items: [
                             {
                                 label: translate("Spellwork Changes"),
-                                value: lessonPackageTranslation?.spellwork_changes ??
+                                value: lessonPackageTranslation.spellwork_changes ??
                                     lessonPackage.content.spellwork_changes
                                         ?.map(change => translate("{$replacement} instead of {$base}", {
                                         base: renderSpellworkAdjustment(translateMap, getInstanceById, change.base),

package/lib/entities/derivedCharacteristic.js

@@ -34,7 +34,7 @@ const getRaceBaseValue = (translate, translateMap, getInstanceById, idMap, raceB
 const renderBaseCalculation = (getInstanceById, translate, translateMap, idMap, calculation, style = "full") => renderMathOperation(calculation, value => {
     switch (value.kind) {
         case "Constant":
-            return value.Constant.toString(10);
+            return value.Constant.toFixed();
         case "Attribute":
             return getAttribute(getInstanceById, translateMap, value.Attribute, style);
         case "RaceBaseValue":

package/lib/entities/disease.js

@@ -2,7 +2,7 @@ import { ensureNonEmpty } from "@elyukai/utils/array/nonEmpty";
 import { isNotNullish } from "@elyukai/utils/nullable";
 import { createEntityDescriptionCreator } from "../creator.js";
 import { renderAnimalTypesSection } from "./partial/animalTypes.js";
-import { renderAlternativeNames, renderChance, renderResistance, } from "./partial/herbary.js";
+import { renderAlternativeNames, renderChance, renderResistance } from "./partial/herbary.js";
 import { parensIf } from "./partial/rated/activatable/parensIf.js";
 import { MISSING_VALUE } from "./partial/unknown.js";
 const renderCauses = (translate, translateMap, causes) => causes
@@ -12,10 +12,7 @@ const renderCauses = (translate, translateMap, causes) => causes
         return MISSING_VALUE;
     }
     return (causeTranslation.name +
-        parensIf(ensureNonEmpty([
-            renderChance(translate, translateMap, cause, true),
-            causeTranslation.note,
-        ].filter(isNotNullish))?.join("; ")));
+        parensIf(ensureNonEmpty([renderChance(translate, translateMap, cause, true), causeTranslation.note].filter(isNotNullish))?.join("; ")));
 })
     .join(", ");
 /**
@@ -35,7 +32,7 @@ export const getDiseaseEntityDescription = createEntityDescriptionCreator(({ get
                 type: "definitionList",
                 items: [
                     renderAlternativeNames(translate, translation.alternative_names),
-                    { label: translate("Level"), value: baseEntry.level.toString() },
+                    { label: translate("Level"), value: baseEntry.level.toFixed() },
                     { label: translate("Progress"), value: translation.progress },
                     {
                         label: translate("Resistance"),