@optolith/entity-descriptions 0.4.10 → 0.4.12

package/lib/entities/race.js

@@ -1,29 +1,34 @@
 import { anySameIndices } from "@elyukai/utils/array/filters";
-import { isNotEmpty } from "@elyukai/utils/array/nonEmpty";
+import { ensureNonEmpty, isNotEmpty } from "@elyukai/utils/array/nonEmpty";
 import { deepEqual } from "@elyukai/utils/equality";
 import { on } from "@elyukai/utils/function";
-import { isNotNullish } from "@elyukai/utils/nullable";
+import { isNotNullish, mapNullable } from "@elyukai/utils/nullable";
+import { compareNumber } from "@elyukai/utils/ordering";
 import { Reader } from "@elyukai/utils/reader";
 import { sign } from "@elyukai/utils/string/number";
 import { createEntityDescriptionCreator } from "../creator.js";
-import { renderCommonnessRatedAdvantagesAndDisadvantages, renderCommonnessRatedAdvantagesOrDisadvantages, renderValueWithPossibleTranslation, } from "./partial/commonnessRatedAdvantagesAndDisadvantages.js";
-import { attributedCustomName, attributedName } from "./partial/markdown.js";
+import { renderCommonnessRatedAdvantagesAndDisadvantages, renderCommonnessRatedAdvantagesOrDisadvantages, } from "./partial/commonnessRatedAdvantagesAndDisadvantages.js";
+import { attributedCustomName, attributedName, attributedNameFromTranslation, } from "./partial/markdown.js";
+import { getInstanceByIdR, translateMapR, } from "./partial/reader.js";
 import { MISSING_VALUE } from "./partial/unknown.js";
-const renderBaseValueItem = (label, value) => Reader.asks(({ translate }) => ({
-    label: translate(label),
-    value: value < 0 ? sign(value) : value.toFixed(),
-}));
-const renderAttributeAdjustmentsItem = (totalAttributesCount, adjustments) => Reader.asks(({ translate, translateMap, localeJoin, getInstanceById, }) => {
+const renderBaseValues = (values) => Reader.traverse(Object.entries(values), ([id, { value }]) => getInstanceByIdR("DerivedCharacteristic", id).thenW(derivedCharacteristic => translateMapR(derivedCharacteristic?.translations).thenW(translation => Reader.asks(({ translate }) => [
+    derivedCharacteristic?.position ?? 0,
+    {
+        label: translate("{$derivedCharacteristic} Base Value", {
+            derivedCharacteristic: attributedNameFromTranslation(translation, "base-values", "DerivedCharacteristic", id) ?? MISSING_VALUE,
+        }),
+        value: value < 0 ? sign(value) : value.toFixed(),
+    },
+])))).map(items => items.sort(on(item => item[0], compareNumber)).map(item => item[1]));
+const renderAttributeAdjustmentsItem = (totalAttributesCount, adjustments) => Reader.asks(({ translate, translateMap, localeJoin, getInstanceById }) => {
     const getAttributeAbbreviation = (id) => attributedCustomName(translateMap, getInstanceById, "race", t => t.abbreviation, "Attribute", id) ?? MISSING_VALUE;
-    return {
-        label: translate("Attribute Adjustments"),
-        value: [
-            ...(adjustments.fixed?.map(adj => `${getAttributeAbbreviation(adj.id)} ${sign(adj.value)}`) ?? []),
-            ...(adjustments.selectable?.map(adj => `${adj.list.length === totalAttributesCount ? translate("one attribute of your choice") : localeJoin(adj.list.map(getAttributeAbbreviation), "disjunction")} ${sign(adj.value)}`) ?? []),
-        ].join("; "),
-    };
+    return [
+        ...(adjustments.fixed?.map(adj => `${getAttributeAbbreviation(adj.id)} ${sign(adj.value)}`) ??
+            []),
+        ...(adjustments.selectable?.map(adj => `${adj.list.length === totalAttributesCount ? translate("one attribute of your choice") : localeJoin(adj.list.map(getAttributeAbbreviation), "disjunction")} ${sign(adj.value)}`) ?? []),
+    ].join("; ");
 });
-const renderVariantValues = (label, variants, selector, renderValue, translationSelector) => Reader.asks(({ translate, translateMap, localeCompare, localeJoin, }) => {
+const renderVariantValues = (label, variants, selector, renderValue, translationSelector, allowEmpty = false, textPrefix) => Reader.asks(({ translate, translateMap, localeCompare, localeJoin, }) => {
     const values = variants.map(variant => {
         const translation = translateMap(variant.translations);
         return {
@@ -34,37 +39,52 @@ const renderVariantValues = (label, variants, selector, renderValue, translation
                 : undefined,
         };
     });
-    const sameValues = anySameIndices(values, on(value => [value.value, value.valueTranslation], deepEqual));
-    if (isNotEmpty(sameValues) &&
-        sameValues.length === 1 &&
-        sameValues[0].length === values.length) {
-        return {
-            label: translate(label),
-            value: values[0] === undefined
-                ? MISSING_VALUE
-                : (values[0].valueTranslation ?? renderValue(values[0].value)),
-        };
+    if (isNotEmpty(values)) {
+        const sameValues = anySameIndices(values, on(value => [value.value, value.valueTranslation], deepEqual));
+        if (values.length === 1 ||
+            (isNotEmpty(sameValues) &&
+                sameValues.length === 1 &&
+                sameValues[0].length === values.length)) {
+            return values[0].value === undefined &&
+                values[0].valueTranslation === undefined &&
+                allowEmpty
+                ? undefined
+                : mapNullable(
+                /* values[0].valueTranslation ?? */ renderValue(values[0].value, false), renderedValue => ({
+                    label: translate(label),
+                    value: (textPrefix ?? "") + renderedValue,
+                }));
+        }
+        else {
+            return {
+                label: translate(label),
+                value: [
+                    ...(textPrefix !== undefined ? [{ type: "plain", text: textPrefix }] : []),
+                    {
+                        type: "definitionList",
+                        style: "nested",
+                        items: Map.groupBy(values
+                            .toSorted(on(item => item.name, localeCompare))
+                            .map(value => mapNullable(
+                        /* value.valueTranslation ?? */ renderValue(value.value, true), renderedValue => ({
+                            label: value.name,
+                            value: renderedValue,
+                        })))
+                            .filter(isNotNullish), item => item.value)
+                            .entries()
+                            .map(([value, items]) => ({
+                            label: localeJoin(items.map(item => item.label), "conjunction"),
+                            value,
+                        }))
+                            .toArray(),
+                    },
+                ],
+            };
+        }
     }
     else {
-        return {
-            label: translate(label),
-            value: [
-                {
-                    type: "definitionList",
-                    style: "nested",
-                    items: Map.groupBy(values.toSorted(on(item => item.name, localeCompare)).map(value => ({
-                        label: value.name,
-                        value: value.valueTranslation ?? renderValue(value.value),
-                    })), item => item.value)
-                        .entries()
-                        .map(([value, items]) => ({
-                        label: localeJoin(items.map(item => item.label), "conjunction"),
-                        value,
-                    }))
-                        .toArray(),
-                },
-            ],
-        };
+        // at least one value and thus one variant is required
+        return undefined;
     }
 });
 const renderAutomaticAdvantagesOrDisadvantages = (entity, items) => Reader.asks(({ translate, translateMap, getInstanceById, localeCompare }) => items === undefined || !isNotEmpty(items)
@@ -83,7 +103,7 @@ const renderCommonCultures = (items) => Reader.asks(({ translate, translateMap,
 /**
  * Get a JSON representation of the rules text for a race.
  */
-export const getRaceEntityDescription = createEntityDescriptionCreator(({ getInstanceById, countInstances, getChildInstancesForInstanceId }, { translate, translateMap, join: localeJoin, compare: localeCompare }, { id, content: entry }) => {
+export const getRaceEntityDescription = createEntityDescriptionCreator(({ getInstanceById, countInstances, getChildInstancesForInstanceId, getResolvedSelectOptionById, }, { translate, translateMap, join: localeJoin, compare: localeCompare }, { id, content: entry }) => {
     const translation = translateMap(entry.translations);
     if (translation === undefined) {
         return undefined;
@@ -95,6 +115,7 @@ export const getRaceEntityDescription = createEntityDescriptionCreator(({ getIns
         translateMap,
         localeJoin,
         localeCompare,
+        getResolvedSelectOptionById,
         getInstanceById,
     };
     return {
@@ -110,29 +131,29 @@ export const getRaceEntityDescription = createEntityDescriptionCreator(({ getIns
                             value: entry.ap_value,
                         }),
                     },
-                    renderBaseValueItem("Life Point Base Value", entry.base_values.life_points).run(env),
-                    renderBaseValueItem("Spirit Base Value", entry.base_values.spirit).run(env),
-                    renderBaseValueItem("Toughness Base Value", entry.base_values.toughness).run(env),
-                    renderBaseValueItem("Movement Base Value", entry.base_values.movement).run(env),
-                    renderAttributeAdjustmentsItem(totalAttributesCount, entry.attribute_adjustments).run(env),
+                    ...renderBaseValues(entry.base_values).run(env),
+                    renderVariantValues("Attribute Adjustments", raceVariants, v => v.attribute_adjustments, attrs => renderAttributeAdjustmentsItem(totalAttributesCount, attrs).run(env)).run(env),
                     renderVariantValues("Common Cultures", raceVariants, v => v.common_cultures, cultures => renderCommonCultures(cultures).run(env)).run(env),
-                    entry.automatic_advantages === undefined
-                        ? undefined
-                        : renderValueWithPossibleTranslation("Automatic Advantages", entry.automatic_advantages, v => renderAutomaticAdvantagesOrDisadvantages("Advantage", v).run(env), translation.automatic_advantages).run(env),
-                    entry.automatic_disadvantages === undefined
-                        ? undefined
-                        : renderValueWithPossibleTranslation("Automatic Disadvantages", entry.automatic_disadvantages, v => renderAutomaticAdvantagesOrDisadvantages("Disadvantage", v).run(env), translation.automatic_disadvantages).run(env),
-                    entry.strongly_recommended_advantages === undefined &&
-                        entry.strongly_recommended_disadvantages === undefined
+                    renderVariantValues("Automatic Advantages", raceVariants, v => v.automatic_advantages, advs => renderAutomaticAdvantagesOrDisadvantages("Advantage", advs).run(env), vt => vt.automatic_advantages, true).run(env),
+                    renderVariantValues("Automatic Disadvantages", raceVariants, v => v.automatic_disadvantages, advs => renderAutomaticAdvantagesOrDisadvantages("Disadvantage", advs).run(env), vt => vt.automatic_disadvantages, true).run(env),
+                    renderVariantValues("Strongly recommended Advantages and Disadvantages", raceVariants, v => v.strongly_recommended_advantages === undefined &&
+                        v.strongly_recommended_disadvantages === undefined
                         ? undefined
-                        : {
-                            label: translate("Strongly recommended Advantages and Disadvantages"),
-                            value: `${translate("The following advantages and disadvantages distinguish Aventurian {$race}. You should choose these advantages and disadvantages. If you don’t want to take them, talk to your GM.", { race: translation.name })} ${renderCommonnessRatedAdvantagesAndDisadvantages(entry.strongly_recommended_advantages, entry.strongly_recommended_disadvantages).run(env)}`,
-                        },
-                    renderVariantValues("Common Advantages", raceVariants, v => v.common_advantages, advs => renderCommonnessRatedAdvantagesOrDisadvantages("Advantage", advs).run(env), vt => vt.common_advantages).run(env),
-                    renderVariantValues("Common Disadvantages", raceVariants, v => v.common_disadvantages, advs => renderCommonnessRatedAdvantagesOrDisadvantages("Disadvantage", advs).run(env), vt => vt.common_disadvantages).run(env),
-                    renderVariantValues("Uncommon Advantages", raceVariants, v => v.uncommon_advantages, advs => renderCommonnessRatedAdvantagesOrDisadvantages("Advantage", advs).run(env), vt => vt.uncommon_advantages).run(env),
-                    renderVariantValues("Uncommon Disadvantages", raceVariants, v => v.uncommon_disadvantages, advs => renderCommonnessRatedAdvantagesOrDisadvantages("Disadvantage", advs).run(env), vt => vt.uncommon_disadvantages).run(env),
+                        : [
+                            v.strongly_recommended_advantages,
+                            v.strongly_recommended_disadvantages,
+                        ], (advsDisadvs, isSplit) => advsDisadvs === undefined
+                        ? isSplit
+                            ? undefined
+                            : translate("none")
+                        : renderCommonnessRatedAdvantagesAndDisadvantages(...advsDisadvs, isSplit ? undefined : translate("none")).run(env), vt => ensureNonEmpty([
+                        vt.strongly_recommended_advantages,
+                        vt.strongly_recommended_disadvantages,
+                    ].filter(isNotNullish))?.join("; "), true, `${translate("The following advantages and disadvantages distinguish Aventurian {$race}. You should choose these advantages and disadvantages. If you don’t want to take them, talk to your GM.", { race: translation.name })} `).run(env),
+                    renderVariantValues("Common Advantages", raceVariants, v => v.common_advantages, (advs, isSplit) => renderCommonnessRatedAdvantagesOrDisadvantages("Advantage", advs, isSplit ? undefined : translate("none")).run(env), vt => vt.common_advantages).run(env),
+                    renderVariantValues("Common Disadvantages", raceVariants, v => v.common_disadvantages, (advs, isSplit) => renderCommonnessRatedAdvantagesOrDisadvantages("Disadvantage", advs, isSplit ? undefined : translate("none")).run(env), vt => vt.common_disadvantages).run(env),
+                    renderVariantValues("Uncommon Advantages", raceVariants, v => v.uncommon_advantages, (advs, isSplit) => renderCommonnessRatedAdvantagesOrDisadvantages("Advantage", advs, isSplit ? undefined : translate("none")).run(env), vt => vt.uncommon_advantages).run(env),
+                    renderVariantValues("Uncommon Disadvantages", raceVariants, v => v.uncommon_disadvantages, (advs, isSplit) => renderCommonnessRatedAdvantagesOrDisadvantages("Disadvantage", advs, isSplit ? undefined : translate("none")).run(env), vt => vt.uncommon_disadvantages).run(env),
                 ],
             },
         ],

package/lib/entities/skill.d.ts

@@ -1,4 +1,4 @@
-import type { ActivatableIdentifier } from "optolith-database-schema/gen";
+import type { ActivatableIdentifier } from "@optolith/database-schema/gen";
 import type { GetAllChildInstancesForParent, GetAllInstances, GetInstanceById } from "../helpers/getTypes.js";
 import type { GetAllResolvedNewSkillApplications, GetAllResolvedSkillUses } from "../index.js";
 /**

package/lib/entities/spell.d.ts

@@ -1,6 +1,7 @@
-import { type RatedIdentifier } from "optolith-database-schema/gen";
+import { type ActivatableIdentifier, type RatedIdentifier } from "@optolith/database-schema/gen";
 import type { GetAllChildInstancesForParent, 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 cantrip.
  */
@@ -72,7 +73,8 @@ export declare const getAnimistPowerEntityDescription: import("../creator.js").E
  * Get a JSON representation of the rules text for a Goede ritual.
  */
 export declare const getGeodeRitualEntityDescription: import("../creator.js").EntityDescriptionCreator<"GeodeRitual", {
-    getInstanceById: GetInstanceById<"Publication" | "Attribute" | "SkillModificationLevel" | "TargetCategory" | "Property" | "MagicalTradition" | "DerivedCharacteristic" | "Influence">;
+    getInstanceById: GetInstanceById<"Publication" | "Attribute" | "SkillModificationLevel" | "TargetCategory" | "Property" | "MagicalTradition" | "DerivedCharacteristic" | "Influence" | ActivatableIdentifier["kind"] | "Aspect">;
+    getResolvedSelectOptionById: GetResolvedSelectOptionById;
 }, import("../index.js").EntityDescription>;
 /**
  * Get a JSON representation of the rules text for a jester trick.

package/lib/entities/spell.js

@@ -666,7 +666,7 @@ export const getAnimistPowerEntityDescription = createEntityDescriptionCreator((
 /**
  * Get a JSON representation of the rules text for a Goede ritual.
  */
-export const getGeodeRitualEntityDescription = createEntityDescriptionCreator(({ getInstanceById }, locale, { content: entry }) => {
+export const getGeodeRitualEntityDescription = createEntityDescriptionCreator(({ getInstanceById, getResolvedSelectOptionById }, locale, { content: entry }) => {
     const { translate, translateMap } = locale;
     const translation = translateMap(entry.translations);
     if (translation === undefined) {
@@ -707,7 +707,7 @@ export const getGeodeRitualEntityDescription = createEntityDescriptionCreator(({
                         ? undefined
                         : {
                             label: translate("Prerequisites"),
-                            value: printGeodeRitualPrerequisites(getInstanceById, locale, entry.prerequisites),
+                            value: printGeodeRitualPrerequisites(getInstanceById, getResolvedSelectOptionById, locale, entry.prerequisites),
                         },
                     renderProperty(entry.property).run(env),
                     {
@@ -836,7 +836,7 @@ const renderMagicalRuneCost = (options, cost) => {
     }
 };
 const renderSplitMagicalRuneParameterTranslation = (parameter) => responsiveR(() => parameter.fast.full, () => parameter.fast.abbr).map2(responsiveR(() => parameter.slow.full, () => parameter.slow.abbr), (fast, slow) => `${slow} / ${fast}`);
-const renderMagicalRunCraftingTimePart = (craftingTime, unit) => formatTimeSpanR(unit, craftingTime.value).thenW(text => {
+const renderMagicalRuneCraftingTimePart = (craftingTime, unit) => formatTimeSpanR(unit, craftingTime.value).thenW(text => {
     if (craftingTime.per === undefined) {
         return Reader.of(text);
     }
@@ -851,7 +851,7 @@ const renderMagicalRunCraftingTimePart = (craftingTime, unit) => formatTimeSpanR
         }));
     });
 });
-const renderMagicalRuneCraftingTime = (craftingTime) => renderMagicalRunCraftingTimePart(craftingTime, "Actions").map2(renderMagicalRunCraftingTimePart(craftingTime, "Days"), (fast, slow) => `${slow} / ${fast}`);
+const renderMagicalRuneCraftingTime = (craftingTime) => renderMagicalRuneCraftingTimePart(craftingTime, "Actions").map2(renderMagicalRuneCraftingTimePart(craftingTime, "Days"), (fast, slow) => `${slow} / ${fast}`);
 const renderMagicalRuneDuration = (duration) => renderCheckResultBasedDuration(duration.fast).map2(renderCheckResultBasedDuration(duration.slow), (fast, slow) => `${slow} / ${fast}`);
 const renderMagicalRuneImprovementCost = (options, improvementCost) => {
     switch (improvementCost.kind) {

package/lib/helpers/getTypes.d.ts

@@ -1,4 +1,4 @@
-import type * as Database from "optolith-database-schema/gen";
+import type * as Database from "@optolith/database-schema/gen";
 import type { IdArgsVariant } from "tsondb/schema/gen";
 export type GetInstanceById<in T extends Extract<keyof Database.EntityMap, string>> = <U extends T>(...args: IdArgsVariant<Database.EntityMap, U>) => Database.EntityMap[U] | undefined;
 export type GetAllInstances<T extends keyof Database.EntityMap> = <U extends T>(entity: U) => {

package/lib/helpers/locale.d.ts

@@ -1,5 +1,5 @@
+import type { LocaleMeasurementAdjustments } from "@optolith/database-schema/gen";
 import type { Compare } from "@optolith/helpers/compare";
-import type { LocaleMeasurementAdjustments } from "optolith-database-schema/gen";
 import type { Format, Translate, TranslateMap } from "./translate.js";
 /**
  * The type of list to join in a locale-aware way.

package/lib/helpers/translate.d.ts

@@ -1,4 +1,4 @@
-import type { Locale } from "optolith-database-schema/gen";
+import type { Locale } from "@optolith/database-schema/gen";
 import { ResponsiveTextSize } from "../entities/partial/responsiveText.js";
 /**
  * The type of all translations