@optolith/entity-descriptions 0.2.1 → 0.3.1

package/lib/entities/liturgicalChant.js

@@ -1,29 +1,31 @@
 import { isNotNullish } from "@optolith/helpers/nullable";
 import { assertExhaustive } from "@optolith/helpers/typeSafety";
-import { createEntityDescriptionCreator, } from "../index.js";
-import { getDurationTranslationForBlessing } from "./partial/rated/activatable/duration.js";
-import { getTextForEffect } from "./partial/rated/activatable/effect.js";
-import { Entity } from "./partial/rated/activatable/entity.js";
-import { getFastOneTimePerformanceParametersTranslations, getFastSustainedPerformanceParametersTranslations, getSlowOneTimePerformanceParametersTranslations, getSlowSustainedPerformanceParametersTranslations, } from "./partial/rated/activatable/index.js";
-import { getTextForBlessingRange } from "./partial/rated/activatable/range.js";
-import { getTargetCategoryTranslation } from "./partial/rated/activatable/targetCategory.js";
-import { createImprovementCost } from "./partial/rated/improvementCost.js";
-import { getTextForCheck } from "./partial/rated/skillCheck.js";
+import { createEntityDescriptionCreator } from "../creator.js";
+import { renderOneTimeDuration } from "./partial/rated/activatable/duration.js";
+import { renderEffect } from "./partial/rated/activatable/effect.js";
+import { renderFastPerformanceParameters, renderSlowPerformanceParameters, } from "./partial/rated/activatable/index.js";
+import { ModifiableParameter } from "./partial/rated/activatable/nonModifiableSuffix.js";
+import { renderNonModifiableRange } from "./partial/rated/activatable/range.js";
+import { renderTargetCategory } from "./partial/rated/activatable/targetCategory.js";
+import { renderImprovementCost } from "./partial/rated/improvementCost.js";
+import { renderSkillCheckWithPenalty } from "./partial/rated/skillCheck.js";
 import { ResponsiveTextSize } from "./partial/responsiveText.js";
 const getTextForTraditions = (deps, values) => {
-    const getAspectName = (ref) => deps.translateMap(deps.getAspectById(ref.id.aspect)?.translations)?.name;
+    const getAspectName = (aspectId) => deps.translateMap(deps.getInstanceById("Aspect", aspectId)?.translations)
+        ?.name;
     const text = values
-        .map((trad) => {
-        switch (trad.tag) {
+        .map(trad => {
+        switch (trad.kind) {
             case "GeneralAspect":
-                return getAspectName(trad.general_aspect);
+                return getAspectName(trad.GeneralAspect);
             case "Tradition": {
-                const traditionTranslation = deps.translateMap(deps.getBlessedTraditionById(trad.tradition.tradition.id.blessed_tradition)?.translations);
+                const traditionTranslation = deps.translateMap(deps.getInstanceById("BlessedTradition", trad.Tradition.tradition)
+                    ?.translations);
                 const name = traditionTranslation?.name_compressed ?? traditionTranslation?.name;
                 if (name === undefined) {
                     return undefined;
                 }
-                const aspects = trad.tradition.aspects
+                const aspects = trad.Tradition.aspects
                     ?.map(getAspectName)
                     .filter(isNotNullish)
                     .sort(deps.localeCompare) ?? [];
@@ -46,170 +48,206 @@ const getTextForTraditions = (deps, values) => {
 /**
  * Get a JSON representation of the rules text for a blessing.
  */
-export const getBlessingEntityDescription = createEntityDescriptionCreator(({ getTargetCategoryById }, locale, entry) => {
+export const getBlessingEntityDescription = createEntityDescriptionCreator(({ getInstanceById }, locale, { content: entry }) => {
     const { translate, translateMap } = locale;
     const translation = translateMap(entry.translations);
     if (translation === undefined) {
         return undefined;
     }
-    const range = getTextForBlessingRange(locale, ResponsiveTextSize.Full, entry.parameters.range);
-    const duration = getDurationTranslationForBlessing(locale, ResponsiveTextSize.Full, entry.parameters.duration);
+    const env = {
+        translate,
+        translateMap,
+        getInstanceById,
+        responsiveTextSize: ResponsiveTextSize.Full,
+    };
+    const range = renderNonModifiableRange(entry.parameters.range, false).run(env);
+    const duration = renderOneTimeDuration(entry.parameters.duration).run(env);
     return {
         title: translation.name,
         className: "blessing",
         body: [
             {
-                label: translate("Effect"),
-                value: translation.effect,
-            },
-            {
-                label: translate("Range"),
-                value: range !== translation.range
-                    ? `***${range}*** (${translation.range})`
-                    : range,
+                type: "definitionList",
+                items: [
+                    {
+                        label: translate("Effect"),
+                        value: translation.effect,
+                    },
+                    {
+                        label: translate("Range"),
+                        value: range !== translation.range
+                            ? `***${range}*** (${translation.range})`
+                            : range,
+                    },
+                    {
+                        label: translate("Duration"),
+                        value: duration !== translation.duration
+                            ? `***${duration}*** (${translation.duration})`
+                            : duration,
+                    },
+                    renderTargetCategory(entry.target).run(env),
+                ],
             },
-            {
-                label: translate("Duration"),
-                value: duration !== translation.duration
-                    ? `***${duration}*** (${translation.duration})`
-                    : duration,
-            },
-            getTargetCategoryTranslation(getTargetCategoryById, locale, entry.target),
         ],
+        errata: translation.errata,
         references: entry.src,
     };
 });
 /**
  * Get a JSON representation of the rules text for a liturgical chant.
  */
-export const getLiturgicalChantEntityDescription = createEntityDescriptionCreator(({ getAttributeById, getSpirit, getToughness, getSkillModificationLevelById, getTargetCategoryById, getBlessedTraditionById, getAspectById, }, locale, entry) => {
+export const getLiturgicalChantEntityDescription = createEntityDescriptionCreator(({ getInstanceById, idMap }, locale, { content: entry }) => {
     const { translate, translateMap, compare: localeCompare } = locale;
     const translation = translateMap(entry.translations);
     if (translation === undefined) {
         return undefined;
     }
-    const { castingTime, cost, range, duration } = (() => {
-        switch (entry.parameters.tag) {
-            case "OneTime":
-                return getFastOneTimePerformanceParametersTranslations(getSkillModificationLevelById, locale, Entity.LiturgicalChant, ResponsiveTextSize.Full, entry.parameters.one_time);
-            case "Sustained":
-                return getFastSustainedPerformanceParametersTranslations(getSkillModificationLevelById, locale, Entity.LiturgicalChant, ResponsiveTextSize.Full, entry.parameters.sustained);
-            default:
-                return assertExhaustive(entry.parameters);
-        }
-    })();
+    const env = {
+        translate,
+        translateMap,
+        getInstanceById,
+        localeJoin: locale.join,
+        energyUnit: "KarmaPoints",
+        responsiveTextSize: ResponsiveTextSize.Full,
+        nonModifiableSuffix: (param) => {
+            switch (param) {
+                case ModifiableParameter.CastingTime:
+                    return " (you cannot use a modification on this chant’s liturgical time)";
+                case ModifiableParameter.Cost:
+                    return " (you cannot use a modification on this chant’s cost)";
+                case ModifiableParameter.Range:
+                    return " (you cannot use a modification on this chant’s range)";
+                default:
+                    return assertExhaustive(param);
+            }
+        },
+    };
+    const { castingTime, cost, range, duration } = renderFastPerformanceParameters(entry.parameters).run(env);
     return {
         title: translation.name,
         className: "liturgical-chant",
         body: [
-            getTextForCheck({ translate, translateMap, getAttributeById }, entry.check, {
-                value: entry.check_penalty,
-                responsiveText: ResponsiveTextSize.Full,
-                getSpirit,
-                getToughness,
-            }),
-            ...getTextForEffect(locale, translation.effect),
-            {
-                label: translate("Liturgical Time"),
-                value: castingTime !== translation.casting_time.full
-                    ? `***${castingTime}*** (${translation.casting_time.full})`
-                    : castingTime,
-            },
-            {
-                label: translate("KP Cost"),
-                value: cost !== translation.cost.full
-                    ? `***${cost}*** (${translation.cost.full})`
-                    : cost,
-            },
             {
-                label: translate("Range"),
-                value: range !== translation.range.full
-                    ? `***${range}*** (${translation.range.full})`
-                    : range,
+                type: "definitionList",
+                items: [
+                    renderSkillCheckWithPenalty(entry.check, entry.check_penalty, idMap).run(env),
+                    renderEffect(translation.effect).run(env),
+                    {
+                        label: translate("Liturgical Time"),
+                        value: translation.casting_time &&
+                            castingTime !== translation.casting_time.full
+                            ? `***${castingTime}*** (${translation.casting_time.full})`
+                            : castingTime,
+                    },
+                    {
+                        label: translate("KP Cost"),
+                        value: translation.cost && cost !== translation.cost.full
+                            ? `***${cost}*** (${translation.cost.full})`
+                            : cost,
+                    },
+                    {
+                        label: translate("Range"),
+                        value: translation.range && range !== translation.range.full
+                            ? `***${range}*** (${translation.range.full})`
+                            : range,
+                    },
+                    {
+                        label: translate("Duration"),
+                        value: translation.duration && duration !== translation.duration.full
+                            ? `***${duration}*** (${translation.duration.full})`
+                            : duration,
+                    },
+                    renderTargetCategory(entry.target).run(env),
+                    getTextForTraditions({
+                        translate,
+                        translateMap,
+                        localeCompare,
+                        getInstanceById,
+                    }, entry.traditions),
+                    renderImprovementCost(entry.improvement_cost).run(env),
+                ],
             },
-            {
-                label: translate("Duration"),
-                value: duration !== translation.duration.full
-                    ? `***${duration}*** (${translation.duration.full})`
-                    : duration,
-            },
-            getTargetCategoryTranslation(getTargetCategoryById, locale, entry.target),
-            getTextForTraditions({
-                translate,
-                translateMap,
-                localeCompare,
-                getBlessedTraditionById,
-                getAspectById,
-            }, entry.traditions),
-            createImprovementCost(translate, entry.improvement_cost),
         ],
+        errata: translation.errata,
         references: entry.src,
     };
 });
 /**
  * Get a JSON representation of the rules text for a ceremony.
  */
-export const getCeremonyEntityDescription = createEntityDescriptionCreator(({ getAttributeById, getSpirit, getToughness, getSkillModificationLevelById, getTargetCategoryById, getBlessedTraditionById, getAspectById, }, locale, entry) => {
+export const getCeremonyEntityDescription = createEntityDescriptionCreator(({ getInstanceById, idMap }, locale, { content: entry }) => {
     const { translate, translateMap, compare: localeCompare } = locale;
     const translation = translateMap(entry.translations);
     if (translation === undefined) {
         return undefined;
     }
-    const { castingTime, cost, range, duration } = (() => {
-        switch (entry.parameters.tag) {
-            case "OneTime":
-                return getSlowOneTimePerformanceParametersTranslations(getSkillModificationLevelById, locale, Entity.Ritual, ResponsiveTextSize.Full, entry.parameters.one_time);
-            case "Sustained":
-                return getSlowSustainedPerformanceParametersTranslations(getSkillModificationLevelById, locale, Entity.Ceremony, ResponsiveTextSize.Full, entry.parameters.sustained);
-            default:
-                return assertExhaustive(entry.parameters);
-        }
-    })();
+    const env = {
+        translate,
+        translateMap,
+        getInstanceById,
+        localeJoin: locale.join,
+        energyUnit: "KarmaPoints",
+        responsiveTextSize: ResponsiveTextSize.Full,
+        nonModifiableSuffix: (param) => {
+            switch (param) {
+                case ModifiableParameter.CastingTime:
+                    return " (you cannot use a modification on this ceremony’s ceremonial time)";
+                case ModifiableParameter.Cost:
+                    return " (you cannot use a modification on this ceremony’s cost)";
+                case ModifiableParameter.Range:
+                    return " (you cannot use a modification on this ceremony’s range)";
+                default:
+                    return assertExhaustive(param);
+            }
+        },
+    };
+    const { castingTime, cost, range, duration } = renderSlowPerformanceParameters(entry.parameters).run(env);
     return {
         title: translation.name,
         className: "ceremony",
         body: [
-            getTextForCheck({ translate, translateMap, getAttributeById }, entry.check, {
-                value: entry.check_penalty,
-                responsiveText: ResponsiveTextSize.Full,
-                getSpirit,
-                getToughness,
-            }),
-            ...getTextForEffect(locale, translation.effect),
-            {
-                label: translate("Ceremonial Time"),
-                value: castingTime !== translation.casting_time.full
-                    ? `***${castingTime}*** (${translation.casting_time.full})`
-                    : castingTime,
-            },
-            {
-                label: translate("KP Cost"),
-                value: cost !== translation.cost.full
-                    ? `***${cost}*** (${translation.cost.full})`
-                    : cost,
-            },
-            {
-                label: translate("Range"),
-                value: range !== translation.range.full
-                    ? `***${range}*** (${translation.range.full})`
-                    : range,
-            },
             {
-                label: translate("Duration"),
-                value: duration !== translation.duration.full
-                    ? `***${duration}*** (${translation.duration.full})`
-                    : duration,
+                type: "definitionList",
+                items: [
+                    renderSkillCheckWithPenalty(entry.check, entry.check_penalty, idMap).run(env),
+                    renderEffect(translation.effect).run(env),
+                    {
+                        label: translate("Ceremonial Time"),
+                        value: translation.casting_time &&
+                            castingTime !== translation.casting_time.full
+                            ? `***${castingTime}*** (${translation.casting_time.full})`
+                            : castingTime,
+                    },
+                    {
+                        label: translate("KP Cost"),
+                        value: translation.cost && cost !== translation.cost.full
+                            ? `***${cost}*** (${translation.cost.full})`
+                            : cost,
+                    },
+                    {
+                        label: translate("Range"),
+                        value: translation.range && range !== translation.range.full
+                            ? `***${range}*** (${translation.range.full})`
+                            : range,
+                    },
+                    {
+                        label: translate("Duration"),
+                        value: translation.duration && duration !== translation.duration.full
+                            ? `***${duration}*** (${translation.duration.full})`
+                            : duration,
+                    },
+                    renderTargetCategory(entry.target).run(env),
+                    getTextForTraditions({
+                        translate,
+                        translateMap,
+                        localeCompare,
+                        getInstanceById,
+                    }, entry.traditions),
+                    renderImprovementCost(entry.improvement_cost).run(env),
+                ],
             },
-            getTargetCategoryTranslation(getTargetCategoryById, locale, entry.target),
-            getTextForTraditions({
-                translate,
-                translateMap,
-                localeCompare,
-                getBlessedTraditionById,
-                getAspectById,
-            }, entry.traditions),
-            createImprovementCost(translate, entry.improvement_cost),
         ],
+        errata: translation.errata,
         references: entry.src,
     };
 });

package/lib/entities/optionalRule.d.ts

@@ -1,5 +1,6 @@
-import { OptionalRule } from "optolith-database-schema/types/rule/OptionalRule";
 /**
  * Get a JSON representation of the rules text for an optional rule.
  */
-export declare const getOptionalRuleEntityDescription: import("../index.js").EntityDescriptionCreator<OptionalRule | undefined, object, import("../index.js").EntityDescription>;
+export declare const getOptionalRuleEntityDescription: import("../creator.js").EntityDescriptionCreator<"OptionalRule", {
+    getInstanceById: import("../helpers/getTypes.js").GetInstanceById<"Publication">;
+}, import("../index.js").EntityDescription>;

package/lib/entities/optionalRule.js

@@ -1,8 +1,8 @@
-import { createEntityDescriptionCreator } from "../index.js";
+import { createEntityDescriptionCreator } from "../creator.js";
 /**
  * Get a JSON representation of the rules text for an optional rule.
  */
-export const getOptionalRuleEntityDescription = createEntityDescriptionCreator((_, { translateMap }, entry) => {
+export const getOptionalRuleEntityDescription = createEntityDescriptionCreator((_, { translateMap }, { content: entry }) => {
     const translation = translateMap(entry.translations);
     if (translation === undefined) {
         return undefined;
@@ -10,7 +10,8 @@ export const getOptionalRuleEntityDescription = createEntityDescriptionCreator((
     return {
         title: translation.name,
         className: "optional-rule",
-        body: [{ value: translation.description }],
+        body: [{ type: "plain", text: translation.description }],
+        errata: translation.errata,
         references: entry.src,
     };
 });

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

@@ -0,0 +1,58 @@
+import type { ActivatableIdentifier, ActivatableNameBuilderRules, RequirableSelectOptionIdentifier } from "optolith-database-schema/gen";
+import type { LocaleMap, Translate, TranslateMap } from "../../helpers/translate.js";
+import type { GetResolvedSelectOptionById } from "./prerequisites/single/activatable.js";
+/**
+ * Returns the full name of the activatable entry as well as its components.
+ */
+export type ActivatableNameComponents = {
+    id: ActivatableIdentifier;
+    base: ActivatableNameChunk;
+    options: ActivatableNameChunk | [ActivatableNameChunk, ActivatableNameChunk] | undefined;
+    level: number | undefined;
+    nameBuilderRules: Required<ActivatableNameBuilderRules>;
+};
+/**
+ * Returns the full name of the activatable entry as well as its components.
+ */
+export type CombinedActivatableNameComponents = {
+    id: ActivatableIdentifier;
+    base: ActivatableNameChunk;
+    options: (ActivatableNameChunk | [ActivatableNameChunk, ActivatableNameChunk])[];
+    level: number | undefined;
+    nameBuilderRules: Required<ActivatableNameBuilderRules>;
+};
+/**
+ * A part of the name, which can be a locale map, a string for all locales or a
+ * function returning a string.
+ */
+export type ActivatableNameChunk = LocaleMap<string> | string | ((translateMap: TranslateMap) => string);
+/**
+ * This can be used to render an activatable entry with a selectable level, as it splits the text where the level should be inserted.
+ */
+export declare const renderActivatableNameComponentsWithoutLevel: (translateMap: TranslateMap, components: ActivatableNameComponents) => [beforeLevel: string, afterLevel?: string];
+/**
+ * Renders the name components of an activatable entry.
+ */
+export declare const renderActivatableNameComponents: (translateMap: TranslateMap, components: ActivatableNameComponents, formatAsPrerequisite: boolean) => string;
+/**
+ * Combines multiple name components into a single one when all values except for options are the same, joining options according to the passed function.
+ *
+ * Returns `undefined` if the components cannot be combined.
+ */
+export declare const combineNameComponents: (elements: ActivatableNameComponents[]) => CombinedActivatableNameComponents | undefined;
+/**
+ * Renders the name components of an activatable entry, combining multiple options into one string.
+ */
+export declare const renderCombinedActivatableNameComponents: (translateMap: TranslateMap, components: CombinedActivatableNameComponents, formatAsPrerequisite: boolean, join?: (list: string[]) => string) => string;
+/**
+ * Renders the name components of multiple activatable entries.
+ */
+export declare const renderMultipleStandaloneActivatableNameComponents: (translateMap: TranslateMap, components: ActivatableNameComponents[], formatAsPrerequisite: boolean, join?: (list: string[]) => string) => string;
+/**
+ * Renders the name components of multiple activatable entries, combining parts if possible.
+ */
+export declare const renderActivatableNameComponentsCombinedIfPossible: (translateMap: TranslateMap, components: ActivatableNameComponents[], formatAsPrerequisite: boolean, join?: (list: string[]) => string) => string;
+/**
+ * Gets the name components for an activatable entry.
+ */
+export declare const getNameComponents: <T>(translate: Translate, id: ActivatableIdentifier, options: RequirableSelectOptionIdentifier[] | undefined, level: number | undefined, nameBuilderRules: ActivatableNameBuilderRules | undefined, translations: LocaleMap<T>, getBaseName: (translation: T) => string, getResolvedSelectOptionById: GetResolvedSelectOptionById, displayedInProfession: boolean) => ActivatableNameComponents;