@optolith/entity-descriptions 0.2.1 → 0.3.2

package/lib/entities/partial/reader.js

@@ -0,0 +1,175 @@
+import { isNotNullish } from "@elyukai/utils/nullable";
+import { Reader } from "@elyukai/utils/reader";
+import { assertExhaustive } from "@elyukai/utils/typeSafety";
+import { Speed } from "./rated/activatable/speed.js";
+import { responsive, ResponsiveTextSize } from "./responsiveText.js";
+import { formatEnergy } from "./units/energy.js";
+import { MISSING_VALUE } from "./unknown.js";
+// Specialized constructors for common contexts
+/**
+ * Treats the text as a translation string and applies supplied arguments.
+ */
+export const formatR = (text, args) => Reader.asks(env => env.format(text, args));
+/**
+ * Creates a value from a translation key.
+ */
+export const translateR = (key, ...rest) => Reader.asks(env => env.translate(key, ...rest));
+/**
+ * Returns the `translate` function from the context.
+ */
+export const translateFnR = Reader.asks(env => env.translate);
+/**
+ * Takes the appropriate translation from a locale map.
+ */
+export const translateMapR = (map) => Reader.asks(env => env.translateMap(map));
+/**
+ * Returns the `translateMap` function from the context.
+ */
+export const translateMapFnR = Reader.asks(env => env.translateMap);
+/**
+ * Retrieves the translation for the current locale from the given value’s `translations` property.
+ * @returns `undefined` if the value does not exist or does not have a translation for the current locale, otherwise the translation.
+ */
+export const translationR = (value) => Reader.asks(env => env.translateMap(value?.translations));
+/**
+ * Retrieves a specific property of the specified entry.
+ */
+export const mapTranslationR = (...args) => Reader.asks(env => {
+    const idArgs = args.length === 3 ? [args[0], args[1]] : [args[0]];
+    const fn = args.length === 3 ? args[2] : args[1];
+    const translation = env.translateMap(env.getInstanceById(...idArgs)?.translations);
+    return fn(translation);
+});
+/**
+ * Retrieves the `name` property of the specified entry.
+ */
+export const nameR = (...args) => Reader.asks(env => env.translateMap(env.getInstanceById(...args)?.translations)?.name);
+/**
+ * Retrieves the `name` property of the specified entry.
+ *
+ * Returns {@link MISSING_VALUE} if there is no name for the entry in the locale. This can happen if the entry itself does not exist, or it does not have a translation for the current locale.
+ */
+export const strictNameR = (...args) => nameR(...args).map(name => name ?? MISSING_VALUE);
+/**
+ * Joins a list of strings according to the locale’s rules for the given type.
+ */
+export const localeJoinR = (arr, type) => Reader.asks(env => env.localeJoin(arr, type));
+/**
+ * Returns a function to retrieve an instance from the database by its entity name and ID.
+ */
+export const getInstanceByIdFnR = () => Reader.asks(env => env.getInstanceById);
+/**
+ * Retrieves an instance from the database by its entity name and ID.
+ */
+export const getInstanceByIdR = (...args) => Reader.asks(env => env.getInstanceById(...args));
+/**
+ * Retrieves all instances of an entity from the database by their entity name.
+ */
+export const getAllInstancesR = (entityName) => Reader.asks(env => env.getAllInstances(entityName));
+/**
+ * Retrieves all child instances of an entity from the database by their child entity name and their parent’s identifier.
+ */
+export const getChildInstancesForInstanceIdR = (entityName, parentId) => Reader.asks(env => env.getChildInstancesForInstanceId(entityName, parentId));
+/**
+ * Joins a list of strings according to the locale’s rules for the given type.
+ */
+export const responsiveLocaleJoinR = (arr, type) => Reader.asks(({ localeJoin, responsiveTextSize }) => responsive(responsiveTextSize, () => localeJoin(arr, type), () => {
+    switch (type) {
+        case "conjunction":
+            return " + ";
+        case "disjunction":
+            return " / ";
+        case "unit":
+            return " ";
+        default:
+            return assertExhaustive(type);
+    }
+}));
+/**
+ * Compares two strings according to the locale’s sorting rules.
+ */
+export const localeCompareR = Reader.asks(env => env.localeCompare);
+/**
+ * Sorts an array of strings according to the locale’s sorting rules.
+ */
+export const localeSortR = (arr) => Reader.asks(({ localeCompare }) => arr.toSorted(localeCompare));
+/**
+ * Creates a responsive value from two functions that return the value for the full and compressed version, respectively.
+ */
+export const responsiveR = (full, compressed) => Reader.asks(({ responsiveTextSize }) => responsive(responsiveTextSize, full, compressed));
+/**
+ * Creates a responsive value from two functions that return the value for the full and compressed version, respectively.
+ */
+export const responsiveThenR = (full, compressed) => Reader.asks(env => {
+    switch (env.responsiveTextSize) {
+        case ResponsiveTextSize.Full:
+            return full().run(env);
+        case ResponsiveTextSize.Compressed:
+            return compressed().run(env);
+        default:
+            return assertExhaustive(env.responsiveTextSize);
+    }
+});
+/**
+ * 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 responsive text.
+ */
+export const responsiveTextR = (responsiveText) => Reader.asks(({ responsiveTextSize }) => responsive(responsiveTextSize, () => responsiveText.full, () => responsiveText.compressed));
+/**
+ * Creates a responsive value from a responsive text with an optional compressed variant.
+ */
+export const responsiveTextOptionalR = (responsiveText) => Reader.asks(({ responsiveTextSize }) => responsive(responsiveTextSize, () => responsiveText.full, () => responsiveText.compressed));
+/**
+ * Formats the given energy cost value with the appropriate unit.
+ */
+export const formatEnergyR = (value) => Reader.asks(({ translate, energyUnit }) => formatEnergy(translate, energyUnit, value));
+/**
+ * Formats the given energy cost value with the appropriate unit based on the entity type.
+ */
+export const formatEnergyFnR = Reader.asks(({ translate, energyUnit }) => value => formatEnergy(translate, energyUnit, value));
+/**
+ * Returns a common value for a skill modification level depending on the speed.
+ */
+export const modifiableBySpeedR = (key, level) => Reader.asks(({ speed }) => {
+    switch (speed) {
+        case Speed.Fast:
+            return level.fast[key];
+        case Speed.Slow:
+            return level.slow[key];
+        default:
+            return assertExhaustive(speed);
+    }
+});
+/**
+ * Returns a common value for a skill modification level depending on the speed.
+ */
+export const modifiableBySpeedOptionalR = (key, level) => Reader.asks(({ speed }) => {
+    switch (speed) {
+        case Speed.Fast:
+            return level.fast?.[key];
+        case Speed.Slow:
+            return level.slow?.[key];
+        default:
+            return assertExhaustive(speed);
+    }
+});
+/**
+ * Returns a common value for a skill modification level depending on the speed.
+ */
+export const modifyBySpeedR = Reader.asks(({ speed }) => (key, level) => {
+    switch (speed) {
+        case Speed.Fast:
+            return level.fast[key];
+        case Speed.Slow:
+            return level.slow[key];
+        default:
+            return assertExhaustive(speed);
+    }
+});
+/**
+ * Returns the default values wrapped in a reader if the value is nullish, otherwise applies the given function to the value and returns the result.
+ */
+export const mapNullableR = (defaultValue, fn) => (value) => isNotNullish(value) ? fn(value) : Reader.of(defaultValue);

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

@@ -1,6 +1,7 @@
-import { LocaleMap } from "optolith-database-schema/types/_LocaleMap";
-import { ResponsiveText, ResponsiveTextOptional, ResponsiveTextReplace } from "optolith-database-schema/types/_ResponsiveText";
-import { TranslateMap } from "../../helpers/translate.js";
+import { Reader } from "@elyukai/utils/reader";
+import type { ResponsiveText, ResponsiveTextOptional, ResponsiveTextReplace } from "optolith-database-schema/gen";
+import { type LocaleMap } from "../../helpers/translate.js";
+import { type StdEnv } from "./reader.js";
 /**
  * Whether the entry is displayed in a normal or compressed setting. Normal/full
  * usually means a full library entry display, whether compressed usually means
@@ -26,9 +27,13 @@ export declare const getResponsiveTextOptional: (value: ResponsiveTextOptional |
  * Replaces a text with a given value if a replacement is requested, otherwise
  * just return the given value.
  */
-export declare const replaceTextIfRequested: <Key extends string>(key: Key, translation: LocaleMap<{ [K in Key]?: ResponsiveTextReplace; }> | undefined, translateMap: TranslateMap, responsiveText: ResponsiveTextSize, valueToReplace: string) => string;
+export declare const replaceTextIfNeeded: (translations: LocaleMap<{
+    replacement?: ResponsiveTextReplace;
+}> | undefined, valueToReplace: string) => Reader<StdEnv<"rts" | "tm">, string>;
 /**
  * Appends a note to a given value if a note is requested, otherwise just return
  * the given value.
  */
-export declare const appendNoteIfRequested: <Key extends string>(key: Key, translation: LocaleMap<{ [K in Key]?: ResponsiveTextOptional; }> | undefined, translateMap: TranslateMap, responsiveText: ResponsiveTextSize, valueToAppendTo: string) => string;
+export declare const appendNoteIfNeeded: (translations: LocaleMap<{
+    note?: ResponsiveTextOptional;
+}> | undefined, valueToAppendTo: string) => Reader<StdEnv<"rts" | "tm">, string>;

package/lib/entities/partial/responsiveText.js

@@ -1,6 +1,8 @@
-import { mapNullable } from "@optolith/helpers/nullable";
+import { identity } from "@elyukai/utils/function";
+import { Reader } from "@elyukai/utils/reader";
 import { assertExhaustive } from "@optolith/helpers/typeSafety";
 import { appendInParensIfNotEmpty } from "./rated/activatable/parensIf.js";
+import { responsiveTextOptionalR, responsiveTextR, translateMapR, } from "./reader.js";
 import { MISSING_VALUE } from "./unknown.js";
 /**
  * Whether the entry is displayed in a normal or compressed setting. Normal/full
@@ -47,9 +49,23 @@ export const getResponsiveTextOptional = (value, size) => {
  * Replaces a text with a given value if a replacement is requested, otherwise
  * just return the given value.
  */
-export const replaceTextIfRequested = (key, translation, translateMap, responsiveText, valueToReplace) => mapNullable(translateMap(translation)?.[key], (replacement) => getResponsiveText(replacement, responsiveText).replace("$1", valueToReplace)) ?? valueToReplace;
+export const replaceTextIfNeeded = (translations, valueToReplace) => translateMapR(translations)
+    .with(identity)
+    .then(translation => {
+    if (translation?.replacement === undefined) {
+        return Reader.of(valueToReplace);
+    }
+    return responsiveTextR(translation.replacement).map(note => note.replace("$1", valueToReplace));
+});
 /**
  * Appends a note to a given value if a note is requested, otherwise just return
  * the given value.
  */
-export const appendNoteIfRequested = (key, translation, translateMap, responsiveText, valueToAppendTo) => mapNullable(translateMap(translation)?.[key], (note) => appendInParensIfNotEmpty(getResponsiveTextOptional(note, responsiveText), valueToAppendTo)) ?? valueToAppendTo;
+export const appendNoteIfNeeded = (translations, valueToAppendTo) => translateMapR(translations)
+    .with(identity)
+    .then(translation => {
+    if (translation?.note === undefined) {
+        return Reader.of(valueToAppendTo);
+    }
+    return responsiveTextOptionalR(translation.note).map(note => appendInParensIfNotEmpty(note, valueToAppendTo));
+});

package/lib/entities/partial/units/energy.d.ts

@@ -1,12 +1,9 @@
-import { LocaleEnvironment } from "../../../helpers/locale.js";
-import { Entity } from "../rated/activatable/entity.js";
-type EnergyUnit = "ArcaneEnergy" | "KarmaPoints";
+import type { Translate } from "../../../helpers/translate.js";
 /**
- * Returns the text for an energy unit.
+ * The unit of an energy cost.
  */
-export declare const formatEnergy: (locale: LocaleEnvironment, unit: EnergyUnit, value: number | string) => string;
+export type EnergyUnit = "LifePoints" | "ArcaneEnergy" | "KarmaPoints";
 /**
- * Returns the text for an energy unit that is based on the entity type.
+ * Returns the text for an energy unit.
  */
-export declare const formatEnergyByEntity: (locale: LocaleEnvironment, entity: Entity, value: number | string) => string;
-export {};
+export declare const formatEnergy: (translate: Translate, unit: EnergyUnit, value: number | string) => string;

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

@@ -1,30 +1,12 @@
-import { assertExhaustive } from "@optolith/helpers/typeSafety";
-import { Entity } from "../rated/activatable/entity.js";
 const lengthUnitTranslationKeys = {
-    ArcaneEnergy: "{0} AE",
-    KarmaPoints: "{0} KP",
+    LifePoints: "{$value} LP",
+    ArcaneEnergy: "{$value} AE",
+    KarmaPoints: "{$value} KP",
 };
 /**
  * Returns the text for an energy unit.
  */
-export const formatEnergy = (locale, unit, value) => {
+export const formatEnergy = (translate, unit, value) => {
     const key = lengthUnitTranslationKeys[unit];
-    return locale.translate(key, value);
-};
-/**
- * Returns the text for an energy unit that is based on the entity type.
- */
-export const formatEnergyByEntity = (locale, entity, value) => {
-    switch (entity) {
-        case Entity.Cantrip:
-        case Entity.Spell:
-        case Entity.Ritual:
-            return formatEnergy(locale, "ArcaneEnergy", value);
-        case Entity.Blessing:
-        case Entity.LiturgicalChant:
-        case Entity.Ceremony:
-            return formatEnergy(locale, "KarmaPoints", value);
-        default:
-            return assertExhaustive(entity);
-    }
+    return translate(key, { value });
 };

package/lib/entities/partial/units/length.d.ts

@@ -1,8 +1,26 @@
-import { LocaleEnvironment } from "../../../helpers/locale.js";
+import type { Translate } from "../../../helpers/translate.js";
+import type { StdReader } from "../reader.js";
 import { ResponsiveTextSize } from "../responsiveText.js";
 type LengthUnit = "Steps" | "Miles";
 /**
  * Returns the text for a length unit.
  */
-export declare const formatLength: (locale: LocaleEnvironment, responsiveTextSize: ResponsiveTextSize, unit: LengthUnit, value: number | string) => string;
+export declare const formatLength: (translate: Translate, responsiveTextSize: ResponsiveTextSize, unit: LengthUnit | {
+    kind: LengthUnit;
+}, value: number | string) => string;
+/**
+ * Returns the text for a length unit.
+ */
+export declare const formatLengthR: (unit: LengthUnit | {
+    kind: LengthUnit;
+}, value: number | string) => StdReader<string, "t" | "rts">;
+/**
+ * Returns the text for a length unit.
+ */
+export declare const formatCombinedLengthR: (object: {
+    unit: LengthUnit | {
+        kind: LengthUnit;
+    };
+    value: number | string;
+}) => StdReader<string, "t" | "rts">;
 export {};

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

@@ -1,12 +1,31 @@
+import { Reader } from "@elyukai/utils/reader";
 import { responsive } from "../responsiveText.js";
 const lengthUnitTranslationKeys = {
-    Steps: ["{0} yards", "{0} yd"],
-    Miles: ["{0} miles", "{0} mi."],
+    Steps: [
+        ".input {$value :number} {{{$value} yards}}",
+        "{$value} yards",
+        "{$value} yd",
+    ],
+    Miles: [
+        ".input {$value :number} {{{$value} miles}}",
+        "{$value} miles",
+        "{$value} mi.",
+    ],
 };
 /**
  * Returns the text for a length unit.
  */
-export const formatLength = (locale, responsiveTextSize, unit, value) => {
-    const [fullKey, compressedKey] = lengthUnitTranslationKeys[unit];
-    return responsive(responsiveTextSize, () => locale.translate(fullKey, value), () => locale.translate(compressedKey, value));
+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 }));
 };
+/**
+ * Returns the text for a length unit.
+ */
+export const formatLengthR = (unit, value) => Reader.asks(env => formatLength(env.translate, env.responsiveTextSize, unit, value));
+/**
+ * Returns the text for a length unit.
+ */
+export const formatCombinedLengthR = (object) => Reader.asks(env => formatLength(env.translate, env.responsiveTextSize, object.unit, object.value));

package/lib/entities/partial/units/timeSpan.d.ts

@@ -1,8 +1,29 @@
-import { LocaleEnvironment } from "../../../helpers/locale.js";
+import { Reader } from "@elyukai/utils/reader";
+import type { Translate } from "../../../helpers/translate.js";
+import type { StdEnv } from "../reader.js";
 import { ResponsiveTextSize } from "../responsiveText.js";
-type TimeSpanUnit = "Seconds" | "Minutes" | "Hours" | "Days" | "Weeks" | "Months" | "Years" | "Centuries" | "Actions" | "CombatRounds" | "SeductionActions" | "Rounds";
+/**
+ * Possible units to use for time spans.
+ */
+export type TimeSpanUnit = "Seconds" | "Minutes" | "Hours" | "Days" | "Weeks" | "Months" | "Years" | "Centuries" | "Actions" | "CombatRounds" | "SeductionActions" | "Rounds";
+/**
+ * Returns the text for a time span unit.
+ */
+export declare const formatTimeSpan: (translate: Translate, responsiveTextSize: ResponsiveTextSize, unit: {
+    kind: TimeSpanUnit;
+} | TimeSpanUnit, value: number | string) => string;
+/**
+ * Returns the text for a time span unit.
+ */
+export declare const formatTimeSpanR: (unit: {
+    kind: TimeSpanUnit;
+} | TimeSpanUnit, value: number | string) => Reader<StdEnv<"t" | "rts">, string>;
 /**
  * Returns the text for a time span unit.
  */
-export declare const formatTimeSpan: (locale: LocaleEnvironment, responsiveTextSize: ResponsiveTextSize, unit: TimeSpanUnit, value: number | string) => string;
-export {};
+export declare const formatCombinedTimeSpanR: (object: {
+    unit: {
+        kind: TimeSpanUnit;
+    };
+    value: number | string;
+}) => Reader<StdEnv<"t" | "rts">, string>;

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

@@ -1,22 +1,34 @@
+import { Reader } from "@elyukai/utils/reader";
 import { responsive } from "../responsiveText.js";
+// prettier-ignore
 const timeSpanUnitTranslationKeys = {
-    Seconds: ["{0} seconds", "{0} s"],
-    Minutes: ["{0} minutes", "{0} min"],
-    Hours: ["{0} hours", "{0} h"],
-    Days: ["{0} days", "{0} d"],
-    Weeks: ["{0} weeks", "{0} wks."],
-    Months: ["{0} months", "{0} mos."],
-    Years: ["{0} years", "{0} yrs."],
-    Centuries: ["{0} centuries", "{0} cent."],
-    Actions: ["{0} actions", "{0} act"],
-    CombatRounds: ["{0} combat rounds", "{0} CR"],
-    SeductionActions: ["{0} seduction actions", "{0} SA"],
-    Rounds: ["{0} rounds", "{0} rnds"],
+    Seconds: [".input {$value :number} {{{$value} seconds}}", "{$value} seconds", "{$value} s"],
+    Minutes: [".input {$value :number} {{{$value} minutes}}", "{$value} minutes", "{$value} min"],
+    Hours: [".input {$value :number} {{{$value} hours}}", "{$value} hours", "{$value} h"],
+    Days: [".input {$value :number} {{{$value} days}}", "{$value} days", "{$value} d"],
+    Weeks: [".input {$value :number} {{{$value} weeks}}", "{$value} weeks", ".input {$value :number} {{{$value} wks.}}"],
+    Months: [".input {$value :number} {{{$value} months}}", "{$value} months", ".input {$value :number} {{{$value} mos.}}"],
+    Years: [".input {$value :number} {{{$value} years}}", "{$value} years", ".input {$value :number} {{{$value} yrs.}}"],
+    Centuries: [".input {$value :number} {{{$value} centuries}}", "{$value} centuries", "{$value} cent."],
+    Actions: [".input {$value :number} {{{$value} actions}}", "{$value} actions", "{$value} act"],
+    CombatRounds: [".input {$value :number} {{{$value} combat rounds}}", "{$value} combat rounds", "{$value} CR"],
+    SeductionActions: [".input {$value :number} {{{$value} seduction actions}}", "{$value} seduction actions", "{$value} SA"],
+    Rounds: [".input {$value :number} {{{$value} rounds}}", "{$value} rounds", "{$value} rnds"],
 };
 /**
  * Returns the text for a time span unit.
  */
-export const formatTimeSpan = (locale, responsiveTextSize, unit, value) => {
-    const [fullKey, compressedKey] = timeSpanUnitTranslationKeys[unit];
-    return responsive(responsiveTextSize, () => locale.translate(fullKey, value), () => locale.translate(compressedKey, value));
+export const formatTimeSpan = (translate, responsiveTextSize, unit, value) => {
+    const [fullNumberKey, fullKey, compressedKey] = timeSpanUnitTranslationKeys[typeof unit === "string" ? unit : unit.kind];
+    return responsive(responsiveTextSize, () => translate(typeof value === "number" ? fullNumberKey : fullKey, {
+        value,
+    }), () => translate(compressedKey, { value }));
 };
+/**
+ * Returns the text for a time span unit.
+ */
+export const formatTimeSpanR = (unit, value) => Reader.asks(({ translate, responsiveTextSize }) => formatTimeSpan(translate, responsiveTextSize, unit, value));
+/**
+ * Returns the text for a time span unit.
+ */
+export const formatCombinedTimeSpanR = (object) => formatTimeSpanR(object.unit, object.value);

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

@@ -1,4 +1,8 @@
 /**
  * String to display when a translation that should be present is missing.
  */
-export declare const MISSING_VALUE = "???";
+export declare const MISSING_VALUE = "###MISSING###";
+/**
+ * String to display when a translation that should be present produces an error.
+ */
+export declare const UNHANDLED_VALUE = "###UNHANDLED_ERROR###";

package/lib/entities/partial/unknown.js

@@ -1,4 +1,8 @@
 /**
  * String to display when a translation that should be present is missing.
  */
-export const MISSING_VALUE = "???";
+export const MISSING_VALUE = "###MISSING###";
+/**
+ * String to display when a translation that should be present produces an error.
+ */
+export const UNHANDLED_VALUE = "###UNHANDLED_ERROR###";

package/lib/entities/personalityTrait.d.ts

@@ -0,0 +1,7 @@
+import type { GetInstanceById } from "../helpers/getTypes.js";
+/**
+ * Get a JSON representation of the rules text for a .
+ */
+export declare const getPersonalityTraitEntityDescription: import("../creator.js").EntityDescriptionCreator<"PersonalityTrait", {
+    getInstanceById: GetInstanceById<"Publication" | "Race" | "Culture" | "PersonalityTrait">;
+}, import("../index.js").EntityDescription>;

package/lib/entities/personalityTrait.js

@@ -0,0 +1,56 @@
+import { on } from "@elyukai/utils/function";
+import { compareNullish } from "@elyukai/utils/ordering";
+import { romanize } from "@elyukai/utils/roman";
+import { numAsc } from "@optolith/helpers/compare";
+import { createEntityDescriptionCreator } from "../creator.js";
+import { printPersonalityTraitPrerequisites } from "./partial/prerequisites/index.js";
+import { MISSING_VALUE } from "./partial/unknown.js";
+/**
+ * Get a JSON representation of the rules text for a .
+ */
+export const getPersonalityTraitEntityDescription = createEntityDescriptionCreator(({ getInstanceById }, locale, { content: entry }) => {
+    const { translate, translateMap, join: localeJoin } = locale;
+    const translation = translateMap(entry.translations);
+    if (translation === undefined) {
+        return undefined;
+    }
+    return {
+        title: `${translation.name} (${translate("Level {$level}", {
+            level: romanize(entry.level),
+        })})`,
+        className: "personality-trait",
+        body: [
+            {
+                type: "definitionList",
+                items: [
+                    ...(translation.effects.map(effect => ({
+                        label: effect.label,
+                        value: effect.text,
+                    })) ?? []),
+                    entry.combination_options === undefined
+                        ? undefined
+                        : {
+                            label: translate("Can be combined with"),
+                            value: Map.groupBy(entry.combination_options.map(optionId => getInstanceById("PersonalityTrait", optionId)), option => option?.level ?? null)
+                                .entries()
+                                .toArray()
+                                .toSorted(on(group => group[0], compareNullish(numAsc)))
+                                .map(([level, options]) => level === null
+                                ? MISSING_VALUE
+                                : `${translate("Level {$level}", { level: romanize(level) })} ${localeJoin(options.map(option => translateMap(option?.translations)?.name ??
+                                    MISSING_VALUE), "disjunction")}`)
+                                .join(", "),
+                        },
+                    entry.prerequisites === undefined
+                        ? undefined
+                        : {
+                            label: translate("Prerequisites"),
+                            value: printPersonalityTraitPrerequisites(getInstanceById, locale, entry.prerequisites),
+                        },
+                ],
+            },
+        ],
+        errata: translation.errata,
+        references: entry.src,
+    };
+});

package/lib/entities/poison.d.ts

@@ -0,0 +1,12 @@
+import type { ActivatableIdentifier, RatedIdentifier } from "optolith-database-schema/gen";
+import type { GetInstanceById } from "../helpers/getTypes.js";
+import type { IdMap } from "../index.js";
+import type { GetResolvedSelectOptionById } from "./partial/prerequisites/single/activatable.js";
+/**
+ * Get a JSON representation of the rules text for a poison.
+ */
+export declare const getPoisonEntityDescription: import("../creator.js").EntityDescriptionCreator<"Poison", {
+    getInstanceById: GetInstanceById<"Publication" | "DerivedCharacteristic" | "Disease" | ActivatableIdentifier["kind"] | RatedIdentifier["kind"] | "Race" | "Culture" | "State" | "Enhancement" | "PactCategory" | "PactDomain" | "SocialStatus" | "Aspect" | "Property">;
+    getResolvedSelectOptionById: GetResolvedSelectOptionById;
+    idMap: IdMap;
+}, import("../index.js").EntityDescription>;