@optolith/entity-descriptions 0.13.1 → 0.14.0

package/lib/entities/partial/profession/packages.d.ts

@@ -0,0 +1,67 @@
+import type { NonEmptyArray } from "@elyukai/utils/array/nonEmpty";
+import type { Equality } from "@elyukai/utils/equality";
+import type { AnyNonNullish } from "@elyukai/utils/nullable";
+import { Reader } from "@elyukai/utils/reader";
+import type { ExperienceLevel, Profession_ID, ProfessionPackage, VariantOptionAction } from "@optolith/database-schema/gen";
+import type { StdEnv, StdReader } from "../../../env.js";
+/**
+ * Profession Package with its associated experience level.
+ */
+export type PreparedProfessionPackage = {
+    id: string;
+    content: ProfessionPackage;
+    experienceLevel: ExperienceLevel;
+};
+/**
+ * Collects all profession packages for a given profession and returns them sorted by their associated experience level.
+ */
+export declare const prepareProfessionPackages: (professionId: Profession_ID) => StdReader<PreparedProfessionPackage[], "ibi" | "acibp", "ExperienceLevel", never, "ProfessionPackage">;
+/**
+ * Configuration for retrieving, rendering and combining an option parameter.
+ */
+export type OptionParameterConfig<T, P, R, E> = {
+    selector: (option: T) => P;
+    equality: Equality<P | undefined>;
+    render: (option: P) => Reader<E, R>;
+    renderAsString: (option: P) => Reader<E, string>;
+    emptyText: string;
+    joiner: string;
+};
+type OptionParameterValueMap = [value: unknown, result: unknown][];
+/**
+ * Option parameter configurations for multiple parameters.
+ */
+export type OptionParameterConfigs<T, P extends OptionParameterValueMap, E> = {
+    [K in keyof P]: OptionParameterConfig<T, P[K][0], P[K][1], E>;
+};
+/**
+ * Extract parameters for final text render.
+ */
+type OptionParameterTextRenderParameters<P extends OptionParameterValueMap> = {
+    [K in keyof P]: P[K][1] | string;
+};
+/**
+ * Renders the text for multiple parameters.
+ */
+export type OptionParameterTextRender<P extends OptionParameterValueMap, E> = (...args: OptionParameterTextRenderParameters<P>) => Reader<E, string>;
+/**
+ * Renders a two-parameter option for a list of profession packages.
+ */
+export declare const renderParameterizedOptionForMultiplePackages: <T, P extends OptionParameterValueMap, E>(professionPackages: NonEmptyArray<PreparedProfessionPackage>, optionSelector: (pkg: PreparedProfessionPackage) => T | undefined, allDifferent: {
+    type: "separate";
+    emptyText: string;
+    joiner: string;
+} | {
+    type: "combined";
+}, renderText: OptionParameterTextRender<P, E>, ...configs: OptionParameterConfigs<T, P, E>) => Reader<E, string | undefined>;
+/**
+ * Renders a two-parameter option for a list of profession packages.
+ */
+export declare const renderParameterizedOptionForBaseAndVariant: <T extends AnyNonNullish, P extends OptionParameterValueMap, E>(baseOptions: T | undefined, variantOptions: VariantOptionAction<T>, allDifferent: {
+    type: "separate";
+    emptyText: string;
+    joiner: string;
+} | {
+    type: "combined";
+}, renderRemove: (base: T) => Reader<E, string>, renderAdd: (override: T) => Reader<E, string>, renderText: OptionParameterTextRender<P, E>, ...configs: OptionParameterConfigs<T, P, E>) => Reader<E & StdEnv<"t">, string>;
+export {};

package/lib/entities/partial/profession/packages.js

@@ -0,0 +1,84 @@
+import { allSame } from "@elyukai/utils/array/filters";
+import { on } from "@elyukai/utils/function";
+import { compareNumber } from "@elyukai/utils/ordering";
+import { Reader } from "@elyukai/utils/reader";
+import { assertExhaustive } from "@elyukai/utils/typeSafety";
+import { LOGIC_ERROR } from "../unknown.js";
+import { insteadOfR, renderVariantOptionPaths } from "./variants.js";
+/**
+ * Collects all profession packages for a given profession and returns them sorted by their associated experience level.
+ */
+export 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 renderSeparatedOptionList = (options, render, emptyText, joiner) => Reader.traverse(options, option => option === undefined ? Reader.of(emptyText) : render(option)).map(list => list.join(joiner));
+/**
+ * Renders a two-parameter option for a list of profession packages.
+ */
+export const renderParameterizedOptionForMultiplePackages = (professionPackages, optionSelector, allDifferent, renderText, ...configs) => {
+    const options = professionPackages.map(optionSelector);
+    const [firstOption] = options;
+    const sames = configs.map(config => allSame(options, on(option => (option === undefined ? undefined : config.selector(option)), config.equality)));
+    if (sames.some(same => same)) {
+        if (firstOption === undefined) {
+            return Reader.of(undefined);
+        }
+        return Reader.traverse(configs, (config, configIndex) => sames[configIndex] === true
+            ? config.render(config.selector(firstOption))
+            : renderSeparatedOptionList(options, option => config.renderAsString(config.selector(option)), config.emptyText, config.joiner)).thenW(parameterValues => renderText(...parameterValues));
+    }
+    else {
+        switch (allDifferent.type) {
+            case "combined":
+                return Reader.traverse(configs, config => renderSeparatedOptionList(options, option => config.renderAsString(config.selector(option)), config.emptyText, config.joiner)).thenW(parameterValues => renderText(...parameterValues));
+            case "separate":
+                return renderSeparatedOptionList(options, option => Reader.traverse(configs, config => config.render(config.selector(option))).thenW(parameterValues => renderText(...parameterValues)), allDifferent.emptyText, allDifferent.joiner);
+            default:
+                return assertExhaustive(allDifferent);
+        }
+    }
+};
+/**
+ * Renders a two-parameter option for a list of profession packages.
+ */
+export const renderParameterizedOptionForBaseAndVariant = (baseOptions, variantOptions, allDifferent, renderRemove, renderAdd, renderText, ...configs) => renderVariantOptionPaths(baseOptions, variantOptions, {
+    remove: renderRemove,
+    add: renderAdd,
+    update: (base, override) => {
+        const sames = configs.map(config => config.equality(config.selector(base), config.selector(override)));
+        if (sames.every(same => same)) {
+            return Reader.of(LOGIC_ERROR); // Base and variant would be equal then, so the variant option should be removed or changed
+        }
+        if (sames.some(same => same)) {
+            return Reader.traverse(configs, (config, configIndex) => sames[configIndex] === true
+                ? config.render(config.selector(base))
+                : config
+                    .renderAsString(config.selector(base))
+                    .thenW(baseValue => config
+                    .renderAsString(config.selector(override))
+                    .thenW(overrideValue => insteadOfR(overrideValue, baseValue)))).thenW(parameterValues => renderText(...parameterValues));
+        }
+        else {
+            switch (allDifferent.type) {
+                case "combined":
+                    return Reader.traverse(configs, config => config
+                        .renderAsString(config.selector(base))
+                        .thenW(baseValue => config
+                        .renderAsString(config.selector(override))
+                        .thenW(overrideValue => insteadOfR(overrideValue, baseValue)))).thenW(parameterValues => renderText(...parameterValues));
+                case "separate":
+                    return Reader.traverse(configs, config => config.render(config.selector(base)))
+                        .thenW(parameterValues => renderText(...parameterValues))
+                        .thenW(baseValue => Reader.traverse(configs, config => config.render(config.selector(override)))
+                        .thenW(parameterValues => renderText(...parameterValues))
+                        .thenW(overrideValue => insteadOfR(overrideValue, baseValue)));
+                default:
+                    return assertExhaustive(allDifferent);
+            }
+        }
+    },
+});

package/lib/entities/partial/profession/variants.d.ts

@@ -0,0 +1,21 @@
+import { type AnyNonNullish } from "@elyukai/utils/nullable";
+import { Reader } from "@elyukai/utils/reader";
+import type { ProfessionPackage, ProfessionPackageOptions, ProfessionVariant, ProfessionVariantPackageOptions, VariantOptionAction } from "@optolith/database-schema/gen";
+/**
+ * Renders an option for a profession variant, using the base profession package and the variant's options.
+ */
+export declare const renderVariantOption: <Env, K extends keyof ProfessionVariantPackageOptions>(base: ProfessionPackage, variant: ProfessionVariant, key: K, render: (base: ProfessionPackageOptions[K] | undefined, variant: NonNullable<ProfessionVariantPackageOptions[K]>) => Reader<Env, string>) => Reader<Env, string[]>;
+/**
+ * Render a variant option based on whether it is a removal, addition, or override of the base option.
+ */
+export declare const renderVariantOptionPaths: <T extends AnyNonNullish, Env1, Env2, Env3>(base: T | undefined, variant: VariantOptionAction<T>, paths: {
+    remove: (base: T) => Reader<Env1, string>;
+    add: (variant: T) => Reader<Env2, string>;
+    update: (base: T, variant: T) => Reader<Env3, string>;
+}) => Reader<Env1 & Env2 & Env3, string>;
+/**
+ * Helper for "X instead of Y" text.
+ */
+export declare const insteadOfR: (replacement: string | number, base: string | number) => Reader<{
+    translate: import("../../../helpers/translate.js").Translate;
+}, string>;

package/lib/entities/partial/profession/variants.js

@@ -0,0 +1,31 @@
+import { nullableToArray } from "@elyukai/utils/nullable";
+import { Reader } from "@elyukai/utils/reader";
+import { assertExhaustive } from "@elyukai/utils/typeSafety";
+import { fixedNumberOrString, translateR } from "../reader.js";
+import { MISSING_VALUE } from "../unknown.js";
+/**
+ * Renders an option for a profession variant, using the base profession package and the variant's options.
+ */
+export const renderVariantOption = (base, variant, key, render) => (variant.options?.[key] === undefined
+    ? Reader.of(undefined)
+    : render(base.options?.[key], variant.options[key])).map(text => nullableToArray(text));
+/**
+ * Render a variant option based on whether it is a removal, addition, or override of the base option.
+ */
+export 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);
+    }
+};
+/**
+ * Helper for "X instead of Y" text.
+ */
+export const insteadOfR = (replacement, base) => translateR("{$replacement} instead of {$base}", {
+    replacement: fixedNumberOrString(replacement),
+    base: fixedNumberOrString(base),
+});

package/lib/entities/partial/rated/activatable/cost.js

@@ -3,7 +3,7 @@ import { Reader } from "@elyukai/utils/reader";
 import { mapNullable } from "@optolith/helpers/nullable";
 import { assertExhaustive } from "@optolith/helpers/typeSafety";
 import { renderParameterMap } from "../../map.js";
-import { formatEnergyFnR, formatEnergyR, getInstanceByIdFnR, modifiableBySpeedR, responsiveLocaleJoinR, responsiveR, responsiveTextR, responsiveTranslateR, translateMapR, translateR, } from "../../reader.js";
+import { fixedNumberOrString, formatEnergyFnR, formatEnergyR, getInstanceByIdFnR, modifiableBySpeedR, responsiveLocaleJoinR, responsiveR, responsiveTextR, responsiveTranslateR, responsiveTranslateSplitR, translateMapR, translateR, } from "../../reader.js";
 import { appendNoteIfNeeded, replaceTextIfNeeded } from "../../responsiveText.js";
 import { formatCombinedTimeSpanR } from "../../units/timeSpan.js";
 import { MISSING_VALUE } from "../../unknown.js";
@@ -33,9 +33,11 @@ const appendPerCountableToCostIfNeeded = (value, baseCost) => {
             })));
     });
 };
-const appendPermanentCostIfNeeded = (permanentValue, baseCost) => mapNullable(permanentValue, value => responsiveTranslateR(".input {$value :number} {{, {$value} of which are permanent}}", " ({$value} perm.)", { value }).map(text => baseCost + text)) ?? Reader.of(baseCost);
-const appendElvenPermanentCostIfNeeded = (permanent, baseCost) => mapNullable(permanent, value => responsiveTranslateR(".input {$value :number} {{{$value} permanent AE}}", "{$value} pAE", {
+const appendPermanentCostIfNeeded = (permanentValue, baseCost) => mapNullable(permanentValue, value => responsiveTranslateSplitR(".input {$value :number} {{, {$value} of which are permanent}}", " ({$value} perm.)", { value }, { value: value.toFixed() }).map(text => baseCost + text)) ?? Reader.of(baseCost);
+const appendElvenPermanentCostIfNeeded = (permanent, baseCost) => mapNullable(permanent, value => responsiveTranslateSplitR(".input {$value :number} {{{$value} permanent AE}}", "{$value} pAE", {
     value: value.value,
+}, {
+    value: value.value.toFixed(),
 })
     .thenW(text => replaceTextIfNeeded(value.translations, text))
     .map(text => baseCost + text)) ?? Reader.of(baseCost);
@@ -117,7 +119,7 @@ const renderMultipleOneTimeCosts = (type, value) => {
 export const renderStandaloneCostMap = (value) => renderParameterMap(value, option => Reader.of(option.value), formatEnergyR, value.options.every(option => option.value.permanentValue !== undefined)
     ? {
         format: values => translateR(", {$value} of which are permanent", {
-            value: values,
+            value: fixedNumberOrString(values),
         }),
         // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- is checked beforehand
         render: option => Reader.of(option.value.permanentValue),
@@ -132,7 +134,7 @@ const renderOneTimeCostMap = (value) => {
             return renderParameterMap(value.Modifiable.map, option => deriveModifiableCost(option.initialModificationLevel).map(cost => cost ?? MISSING_VALUE), singleValue => formatEnergyR(singleValue), value.Modifiable.map.options.every(option => option.value.permanentValue !== undefined)
                 ? {
                     format: values => translateR(", {$value} of which are permanent", {
-                        value: values,
+                        value: fixedNumberOrString(values),
                     }),
                     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- is checked beforehand
                     render: option => Reader.of(option.value.permanentValue),
@@ -142,7 +144,7 @@ const renderOneTimeCostMap = (value) => {
             return renderParameterMap(value.NonModifiable.map, option => Reader.of(option.value), formatEnergyR, value.NonModifiable.map.options.every(option => option.value.permanentValue !== undefined)
                 ? {
                     format: values => translateR(", {$value} of which are permanent", {
-                        value: values,
+                        value: fixedNumberOrString(values),
                     }),
                     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- is checked beforehand
                     render: option => Reader.of(option.value.permanentValue),
@@ -240,10 +242,10 @@ export const renderMagicalActionCost = (cost) => {
         case "FirstPerson":
             return Reader.asks(({ translate }) => translate("{$firstPersonValue} for the first person; {$additionalPersonValue} for each additional person", {
                 firstPersonValue: translate("{$value} AE", {
-                    value: cost.FirstPerson.value,
+                    value: cost.FirstPerson.value.toFixed(),
                 }),
                 additionalPersonValue: translate("{$value} AE", {
-                    value: cost.FirstPerson.value / 2,
+                    value: (cost.FirstPerson.value / 2).toFixed(),
                 }),
             }));
         case "ByPrimaryPatron":
@@ -252,7 +254,7 @@ export const renderMagicalActionCost = (cost) => {
             return Reader.asks(({ translate }) => cost.All.minimum === undefined
                 ? translate("All AE")
                 : translate("All AE, at least {$value} AE", {
-                    value: cost.All.minimum,
+                    value: cost.All.minimum.toFixed(),
                 }));
         case "Map":
             return renderStandaloneCostMap(cost.Map);

package/lib/entities/partial/rated/activatable/effect.js

@@ -1,6 +1,6 @@
 import { mapNullable } from "@optolith/helpers/nullable";
 import { assertExhaustive } from "@optolith/helpers/typeSafety";
-import { translateFnR } from "../../reader.js";
+import { fixedNumberOrString, translateFnR } from "../../reader.js";
 const getContentPartsForQualityLevels = (getQualityLevelString, source) => translateFnR.map((translate) => ({
     label: translate("Effect"),
     value: [
@@ -13,7 +13,7 @@ const getContentPartsForQualityLevels = (getQualityLevelString, source) => trans
             style: "hidden",
             items: source.quality_levels.map((text, index) => ({
                 label: translate("QL {$value}", {
-                    value: getQualityLevelString(index),
+                    value: fixedNumberOrString(getQualityLevelString(index)),
                 }),
                 value: text,
             })),

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

@@ -1,6 +1,7 @@
 import { Reader } from "@elyukai/utils/reader";
 import type { ChildEntityMap, EntityMap, FastSkillModificationLevelConfig, ResponsiveText, ResponsiveTextOptional, SkillModificationLevel, SlowSkillModificationLevelConfig } from "@optolith/database-schema/gen";
 import type { IdArgsVariant } from "tsondb/schema/gen";
+import type { StdReader } from "../../env.js";
 import type { GetAllChildInstancesForParent, GetAllInstances, GetInstanceById } from "../../helpers/getTypes.js";
 import type { LocaleCompare, LocaleJoin, LocaleJoinType } from "../../helpers/locale.js";
 import type { Format, LocaleMap, Translate, TranslateMap, TranslationKeyMatchingParamsOfKey, TranslationParamsInArray, Translations } from "../../helpers/translate.js";
@@ -99,7 +100,7 @@ export declare const attributedNameFromInstanceR: (instance: {
     translations: LocaleMap<{
         name: string;
     }>;
-} | undefined, context: string, ...args: IdArgsVariant) => Reader<{
+} | undefined, context: string, ...args: IdArgsVariant<EntityMap, keyof EntityMap>) => Reader<{
     translateMap: TranslateMap;
 }, string | undefined>;
 /**
@@ -204,6 +205,13 @@ export declare const responsiveTranslateR: <K extends keyof Translations, K2 ext
     translate: Translate;
     responsiveTextSize: ResponsiveTextSize;
 }, string>;
+/**
+ * Creates a responsive value from a translation key that has a full and a compressed version.
+ */
+export declare const responsiveTranslateSplitR: <K extends keyof Translations, K2 extends TranslationKeyMatchingParamsOfKey<K>>(fullKey: K, compressedKey: K2, ...rest: [...TranslationParamsInArray<K>, ...TranslationParamsInArray<K2>]) => Reader<{
+    translate: Translate;
+    responsiveTextSize: ResponsiveTextSize;
+}, string>;
 /**
  * Creates a responsive value from a responsive text.
  */
@@ -266,4 +274,20 @@ export declare const mapNullableR: <T, U, R>(defaultValue: U, fn: (value: NonNul
  * Use `Reader` instances directly in a template string.
  */
 export declare const sequence: <E>(string: TemplateStringsArray, ...values: (Reader<E, string> | string)[]) => Reader<E, string>;
+/**
+ * Formats a number according to the locale’s rules, returns a string as-is.
+ */
+export declare const formatNumber: (value: number) => StdReader<string, "fn">;
+/**
+ * Formats an AP value in an appreviated form.
+ */
+export declare const formatAPValue: (value: number) => StdReader<string, "t" | "fn">;
+/**
+ * Formats a number according to the locale’s rules, returns a string as-is.
+ */
+export declare const formatNumberOrString: (value: number | string) => StdReader<string, "fn">;
+/**
+ * Formats a number in fixed-point notation, returns a string as-is.
+ */
+export declare const fixedNumberOrString: (value: number | string, fractionDigits?: number) => string;
 export {};

package/lib/entities/partial/reader.js

@@ -135,6 +135,10 @@ export const responsiveThenR = (full, compressed) => Reader.asks(env => {
  * Creates a responsive value from a translation key that has a full and a compressed version.
  */
 export const responsiveTranslateR = (fullKey, compressedKey, ...rest) => Reader.asks(({ translate, responsiveTextSize }) => responsive(responsiveTextSize, () => translate(fullKey, ...rest), () => translate(compressedKey, ...rest)));
+/**
+ * Creates a responsive value from a translation key that has a full and a compressed version.
+ */
+export const responsiveTranslateSplitR = (fullKey, compressedKey, ...rest) => Reader.asks(({ translate, responsiveTextSize }) => responsive(responsiveTextSize, () => translate(fullKey, ...rest.slice(0, 1)), () => translate(compressedKey, ...rest.slice(1))));
 /**
  * Creates a responsive value from a responsive text.
  */
@@ -198,3 +202,19 @@ export const mapNullableR = (defaultValue, fn) => (value) => isNotNullish(value)
  * Use `Reader` instances directly in a template string.
  */
 export const sequence = (string, ...values) => Reader.traverse(values, value => (value instanceof Reader ? value : Reader.of(value))).map(resolvedValues => string.reduce((acc, str, i) => acc + str + (resolvedValues[i] ?? ""), ""));
+/**
+ * Formats a number according to the locale’s rules, returns a string as-is.
+ */
+export const formatNumber = (value) => Reader.asks(env => env.formatNumber(value));
+/**
+ * Formats an AP value in an appreviated form.
+ */
+export const formatAPValue = (value) => formatNumber(value).thenW(formattedValue => translateR("{$value} AP", { value: formattedValue }));
+/**
+ * Formats a number according to the locale’s rules, returns a string as-is.
+ */
+export const formatNumberOrString = (value) => Reader.asks(env => (typeof value === "number" ? env.formatNumber(value) : value));
+/**
+ * Formats a number in fixed-point notation, returns a string as-is.
+ */
+export const fixedNumberOrString = (value, fractionDigits) => typeof value === "number" ? value.toFixed(fractionDigits) : value;

package/lib/entities/partial/units/energy.js

@@ -1,3 +1,4 @@
+import { fixedNumberOrString } from "../reader.js";
 const lengthUnitTranslationKeys = {
     LifePoints: "{$value} LP",
     ArcaneEnergy: "{$value} AE",
@@ -8,5 +9,5 @@ const lengthUnitTranslationKeys = {
  */
 export const formatEnergy = (translate, unit, value) => {
     const key = lengthUnitTranslationKeys[unit];
-    return translate(key, { value });
+    return translate(key, { value: fixedNumberOrString(value) });
 };

package/lib/entities/partial/units/length.js

@@ -1,4 +1,5 @@
 import { Reader } from "@elyukai/utils/reader";
+import { fixedNumberOrString } from "../reader.js";
 import { responsive } from "../responsiveText.js";
 const lengthUnitTranslationKeys = {
     Steps: [".input {$value :number} {{{$value} yards}}", "{$value} yards", "{$value} yd"],
@@ -9,9 +10,11 @@ const lengthUnitTranslationKeys = {
  */
 export const formatLength = (translate, responsiveTextSize, unit, value) => {
     const [fullNumberKey, fullKey, compressedKey] = lengthUnitTranslationKeys[typeof unit === "string" ? unit : unit.kind];
-    return responsive(responsiveTextSize, () => translate(typeof value === "number" ? fullNumberKey : fullKey, {
-        value,
-    }), () => translate(compressedKey, { value }));
+    return responsive(responsiveTextSize, () => translate(typeof value === "number" ? fullNumberKey : fullKey, typeof value === "number"
+        ? {
+            value,
+        }
+        : { value }), () => translate(compressedKey, { value: fixedNumberOrString(value) }));
 };
 /**
  * Returns the text for a length unit.

package/lib/entities/partial/units/timeSpan.js

@@ -35,13 +35,17 @@ export const formatTimeSpan = (translate, translateMap, format, responsiveTextSi
         }));
     }
     const [fullNumberKey, fullKey, compressedNumberKey, compressedKey] = timeSpanUnitTranslationKeys[typeof unit === "string" ? unit : unit.kind];
-    return responsive(responsiveTextSize, () => translate(typeof value === "number" ? fullNumberKey : fullKey, {
-        value,
-        style: interval ? "interval" : "default",
-    }), () => translate(typeof value === "number" ? compressedNumberKey : compressedKey, {
-        value,
-        style: interval ? "interval" : "default",
-    }));
+    return responsive(responsiveTextSize, () => translate(typeof value === "number" ? fullNumberKey : fullKey, typeof value === "number"
+        ? {
+            value,
+            style: interval ? "interval" : "default",
+        }
+        : { value }), () => translate(typeof value === "number" ? compressedNumberKey : compressedKey, typeof value === "number"
+        ? {
+            value,
+            style: interval ? "interval" : "default",
+        }
+        : { value }));
 };
 /**
  * Returns the text for a time span unit.

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

@@ -6,3 +6,7 @@ export declare const MISSING_VALUE = "###MISSING###";
  * String to display when a translation that should be present produces an error.
  */
 export declare const UNHANDLED_VALUE = "###UNHANDLEDERROR###";
+/**
+ * String to display when there is a logic error in text generation.
+ */
+export declare const LOGIC_ERROR = "###LOGIC_ERROR###";

package/lib/entities/partial/unknown.js

@@ -6,3 +6,7 @@ export const MISSING_VALUE = "###MISSING###";
  * String to display when a translation that should be present produces an error.
  */
 export const UNHANDLED_VALUE = "###UNHANDLEDERROR###";
+/**
+ * String to display when there is a logic error in text generation.
+ */
+export const LOGIC_ERROR = "###LOGIC_ERROR###";

package/lib/entities/poison.js

@@ -379,7 +379,7 @@ export const getPoisonEntityDescription = createEntityDescriptionCreator(({ getI
                         ? undefined
                         : {
                             label: `${translate("AP Value")} (${translate("Trade Secret")})`,
-                            value: translate("{$value} AP", { value: tradeSecret.apValue }) +
+                            value: translate("{$value} AP", { value: tradeSecret.apValue.toFixed() }) +
                                 parensIf(mapNullable(tradeSecret.prerequisites, prerequisites => `${translate("Prerequisites")}: ${printPlainGeneralPrerequisites(prerequisites).run(env)}`)),
                         },
                     entry.source_type.kind === "AlchemicalPoison" ||