@optolith/entity-descriptions 0.2.1 → 0.3.1

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

@@ -1,149 +1,217 @@
-import { mapNullable, mapNullableDefault } from "@optolith/helpers/nullable";
+import { identity } from "@elyukai/utils/function";
+import { Reader } from "@elyukai/utils/reader";
+import { mapNullable } from "@optolith/helpers/nullable";
 import { assertExhaustive } from "@optolith/helpers/typeSafety";
-import { appendNoteIfRequested, getResponsiveText, replaceTextIfRequested, responsive, } from "../../responsiveText.js";
-import { formatEnergyByEntity } from "../../units/energy.js";
-import { formatTimeSpan } from "../../units/timeSpan.js";
+import { renderResponsiveMap } from "../../map.js";
+import { additionFormatter } from "../../mathOperation.js";
+import { formatEnergyFnR, formatEnergyR, getInstanceByIdFnR, modifiableBySpeedR, responsiveLocaleJoinR, responsiveR, responsiveTextR, responsiveTranslateR, translateMapR, translateR, } from "../../reader.js";
+import { appendNoteIfNeeded, replaceTextIfNeeded, } from "../../responsiveText.js";
+import { formatCombinedTimeSpanR } from "../../units/timeSpan.js";
 import { MISSING_VALUE } from "../../unknown.js";
+import { appendCheckResultModifier } from "./checkResultBased.js";
 import { wrapIfMinimum } from "./isMinimumMaximum.js";
-import { getNonModifiableSuffixTranslation, ModifiableParameter, } from "./nonModifiableSuffix.js";
-import { getModifiableBySpeed } from "./speed.js";
-const getModifiableOneTimeCostTranslation = (getSkillModificationLevelById, locale, responsiveTextSize, entity, speed, value) => mapNullable(getSkillModificationLevelById(value.initial_modification_level), (modificationLevel) => {
-    const cost = getModifiableBySpeed((config) => config.cost, (config) => config.cost, speed, modificationLevel);
-    return replaceTextIfRequested("replacement", value.translations, locale.translateMap, responsiveTextSize, formatEnergyByEntity(locale, entity, cost));
-}) ?? MISSING_VALUE;
-const getNonModifiableOneTimeCostPerCountableTranslation = (formatCost, locale, responsiveTextSize, value) => mapNullable(value, (perCountable) => {
-    const entity = getResponsiveText(locale.translateMap(perCountable.translations)?.countable, responsiveTextSize);
-    const countableText = responsive(responsiveTextSize, () => locale.translate(" per {0}", entity), () => locale.translate("/{0}", entity));
-    const minimumTotalText = mapNullable(perCountable.minimum_total, (minimumTotal) => locale.translate(", minimum of {0}", formatCost(minimumTotal))) ?? "";
-    return countableText + minimumTotalText;
-}) ?? "";
-const getPermanentValueTranslation = (locale, responsiveTextSize, permanentValue) => permanentValue === undefined
-    ? ""
-    : responsive(responsiveTextSize, () => locale.translate(", {0} of which are permanent", permanentValue), () => locale.translate(" ({0} perm.)", permanentValue));
-const getNonModifiableOneTimeCostTranslation = (locale, entity, responsiveTextSize, value) => {
-    const formatCostP = formatEnergyByEntity.bind(this, locale, entity);
-    const perCountable = getNonModifiableOneTimeCostPerCountableTranslation(formatCostP, locale, responsiveTextSize, value.per);
-    const permanentValue = getPermanentValueTranslation(locale, responsiveTextSize, value.permanent_value);
-    const costWrappedIfMinimum = wrapIfMinimum(locale, responsiveTextSize, value.is_minimum, formatCostP(value.value) + perCountable + permanentValue);
-    const withNote = appendNoteIfRequested("note", value.translations, locale.translateMap, responsiveTextSize, costWrappedIfMinimum);
-    const cannotModify = getNonModifiableSuffixTranslation(locale, entity, ModifiableParameter.Cost, responsiveTextSize);
-    return withNote + cannotModify;
+import { appendNonModifiableSuffix, ModifiableParameter, } from "./nonModifiableSuffix.js";
+const deriveModifiableCost = (modificationLevelId) => getInstanceByIdFnR().thenW(getInstanceById => mapNullable(getInstanceById("SkillModificationLevel", modificationLevelId), modificationLevel => modifiableBySpeedR("cost", modificationLevel)) ?? Reader.of(undefined));
+const appendPerCountableToCostIfNeeded = (value, baseCost) => {
+    if (value === undefined) {
+        return Reader.of(baseCost);
+    }
+    const { translations, minimum_total } = value;
+    return translateMapR(translations).thenW(translation => {
+        if (translation === undefined) {
+            return Reader.of(baseCost);
+        }
+        return responsiveTextR(translation.countable)
+            .thenW(countable => responsiveTranslateR("{$cost} per {$countable}", "{$cost}/{$countable}", { cost: baseCost, countable }))
+            .thenW(text => minimum_total === undefined
+            ? Reader.of(text)
+            : formatEnergyR(minimum_total).then(cost => translateR("{$baseCost}, minimum of {$value}", {
+                baseCost: text,
+                value: cost,
+            })));
+    });
 };
-const getIndefiniteOneTimeCostTranslation = (locale, entity, responsiveTextSize, value) => getResponsiveText(locale.translateMap(value.translations)?.description, responsiveTextSize) +
-    getNonModifiableSuffixTranslation(locale, entity, ModifiableParameter.Cost, responsiveTextSize);
-const getSingleOneTimeCostTranslation = (getSkillModificationLevelById, locale, speed, entity, responsiveTextSize, value) => {
-    switch (value.tag) {
+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", { value: value.value })
+    .thenW(text => replaceTextIfNeeded(value.translations, text))
+    .map(text => baseCost + text)) ?? Reader.of(baseCost);
+const appendFamiliarsTrickLPCostIfNeeded = (lpValue, baseCost) => lpValue === undefined
+    ? Reader.of(baseCost)
+    : formatEnergyR(lpValue)
+        .with((env) => ({ ...env, energyUnit: "LifePoints" }))
+        .thenW(formattedLpCost => responsiveLocaleJoinR([baseCost, formattedLpCost], "conjunction"));
+/**
+ * Returns the text for the modifiable one-time cost of an activatable skill.
+ */
+export const renderModifiableOneTimeCost = (value) => deriveModifiableCost(value.initial_modification_level).thenW(cost => cost === undefined
+    ? Reader.of(MISSING_VALUE)
+    : formatEnergyR(cost)
+        .thenW(text => replaceTextIfNeeded(value.translations, text))
+        .then(text => translateMapR(value.translations).thenW(translation => {
+        if (translation?.additional === undefined) {
+            return Reader.of(text);
+        }
+        return responsiveTextR(translation.additional).map(additional => additionFormatter(text, additional));
+    })));
+const appendIntervalToCost = (interval, baseCost) => interval === undefined
+    ? Reader.of(baseCost)
+    : formatCombinedTimeSpanR(interval).then(formattedInterval => responsiveTranslateR("{$cost} per {$interval}", "{$cost}/{$interval}", {
+        cost: baseCost,
+        interval: formattedInterval,
+    }));
+/**
+ * Returns the text for a non-modifiable one-time cost of an activatable skill.
+ */
+export const renderNonModifiableOneTimeCost = (value, shouldAppendNonModifiableSuffix) => formatEnergyR(value.value)
+    .thenW(base => appendFamiliarsTrickLPCostIfNeeded(value.lp_value, base))
+    .thenW(base => appendPerCountableToCostIfNeeded(value.per, base))
+    .then(base => appendPermanentCostIfNeeded(value.permanent_value, base))
+    .then(base => appendIntervalToCost(value.interval, base))
+    .then(base => appendElvenPermanentCostIfNeeded(value.permanent, base))
+    .then(base => wrapIfMinimum(value.is_minimum, base))
+    .then(base => appendNoteIfNeeded(value.translations, base))
+    .then(shouldAppendNonModifiableSuffix
+    ? base => appendNonModifiableSuffix(ModifiableParameter.Cost, base)
+    : Reader.of);
+/**
+ * Returns the text for the indefinite cost of an activatable skill.
+ */
+export const renderIndefiniteCost = (value, shouldAppendNonModifiableSuffix) => {
+    const { modifier, translations } = value;
+    return translateMapR(translations)
+        .thenW(translation => translation === undefined
+        ? Reader.of(MISSING_VALUE)
+        : responsiveTextR(translation.description))
+        .map(modifier === undefined
+        ? identity
+        : base => appendCheckResultModifier(base, modifier))
+        .thenW(shouldAppendNonModifiableSuffix
+        ? base => appendNonModifiableSuffix(ModifiableParameter.Cost, base)
+        : Reader.of);
+};
+const renderSingleOneTimeCost = (value) => {
+    switch (value.kind) {
         case "Modifiable":
-            return getModifiableOneTimeCostTranslation(getSkillModificationLevelById, locale, responsiveTextSize, entity, speed, value.modifiable);
+            return renderModifiableOneTimeCost(value.Modifiable);
         case "NonModifiable":
-            return getNonModifiableOneTimeCostTranslation(locale, entity, responsiveTextSize, value.non_modifiable);
+            return renderNonModifiableOneTimeCost(value.NonModifiable, true);
         case "Indefinite":
-            return getIndefiniteOneTimeCostTranslation(locale, entity, responsiveTextSize, value.indefinite);
+            return renderIndefiniteCost(value.Indefinite, true);
         default:
             return assertExhaustive(value);
     }
 };
-const getMultipleOneTimeCostsTranslation = (type, getSkillModificationLevelById, locale, speed, entity, responsiveTextSize, value) => {
-    const modifiable = !value.every((part) => part.tag === "Modifiable")
-        ? getNonModifiableSuffixTranslation(locale, entity, ModifiableParameter.Cost, responsiveTextSize)
-        : "";
-    return (value
-        .map((part) => getSingleOneTimeCostTranslation(getSkillModificationLevelById, locale, speed, entity, responsiveTextSize, part))
-        .join((() => {
-        switch (type) {
-            case "conjunction":
-                return responsive(responsiveTextSize, () => locale.translate(" and "), () => locale.translate(" + "));
-            case "disjunction":
-                return responsive(responsiveTextSize, () => locale.translate(" or "), () => locale.translate(" / "));
-            default:
-                return assertExhaustive(type);
-        }
-    })()) + modifiable);
+const renderMultipleOneTimeCosts = (type, value) => {
+    const appendNonModifiableIfRequested = !value.every(part => part.kind === "Modifiable")
+        ? (text) => appendNonModifiableSuffix(ModifiableParameter.Cost, text)
+        : Reader.of;
+    return Reader.sequence(value.map(renderSingleOneTimeCost))
+        .thenW(list => responsiveLocaleJoinR(list, type))
+        .then(text => appendNonModifiableIfRequested(text));
 };
-const getCostMapTranslation = (locale, entity, responsiveTextSize, value) => {
-    const translation = locale.translateMap(value.translations);
-    if (value.translations !== undefined && translation === undefined) {
-        return MISSING_VALUE;
-    }
-    if (translation?.replacement !== undefined) {
-        return translation.replacement;
+/**
+ * Returns the text for a one-time cost map of an activatable skill.
+ */
+export const renderOneTimeCostMap = (value) => Reader.asks(({ translate }) => translate).thenW(translate => formatEnergyFnR
+    .thenW(formatEnergy => renderResponsiveMap(value, option => option.value, formatEnergy, value.options.every(option => option.permanent_value !== undefined)
+    ? {
+        surround: values => translate(", {$value} of which are permanent", {
+            value: values,
+        }),
+        getAdditionalValue: option => option.permanent_value,
     }
-    const labels = value.options
-        .map((option) => locale.translateMap(option.translations)?.label ?? MISSING_VALUE)
-        .join("/");
-    const costs = value.options.map((option) => option.value).join("/");
-    const permanentCosts = value.options.every((option) => option.permanent_value !== undefined)
-        ? value.options.map((option) => option.permanent_value).join("/")
-        : undefined;
-    const formatCostP = formatEnergyByEntity.bind(this, locale, entity);
-    const notModifiable = getNonModifiableSuffixTranslation(locale, entity, ModifiableParameter.Cost, responsiveTextSize);
-    return (formatCostP(costs) +
-        locale.translate(" for ") +
-        mapNullableDefault(translation?.list_prepend, (listPrepend) => `${listPrepend} `, "") +
-        labels +
-        (translation?.list_append ?? "") +
-        (permanentCosts !== undefined
-            ? locale.translate(", {0} of which are permanent", formatCostP(permanentCosts))
-            : "") +
-        notModifiable);
-};
+    : undefined))
+    .then(text => appendNonModifiableSuffix(ModifiableParameter.Cost, text)));
+const renderSustainedCostMap = (value) => formatEnergyFnR
+    .thenW(formatEnergy => renderResponsiveMap(value, option => option.value, formatEnergy))
+    .then(text => appendNonModifiableSuffix(ModifiableParameter.Cost, text));
 /**
  * Returns the text for the cost of a one-time activatable skill.
  */
-export const getOneTimeCostTranslation = (getSkillModificationLevelById, locale, speed, entity, responsiveTextSize, value) => {
-    switch (value.tag) {
+export const renderOneTimeCost = (value) => {
+    switch (value.kind) {
         case "Single":
-            return getSingleOneTimeCostTranslation(getSkillModificationLevelById, locale, speed, entity, responsiveTextSize, value.single);
+            return renderSingleOneTimeCost(value.Single);
         case "Conjunction":
-            return getMultipleOneTimeCostsTranslation("conjunction", getSkillModificationLevelById, locale, speed, entity, responsiveTextSize, value.conjunction);
+            return renderMultipleOneTimeCosts("conjunction", value.Conjunction);
         case "Disjunction":
-            return getMultipleOneTimeCostsTranslation("disjunction", getSkillModificationLevelById, locale, speed, entity, responsiveTextSize, value.disjunction);
+            return renderMultipleOneTimeCosts("disjunction", value.Disjunction);
         case "Map":
-            return getCostMapTranslation(locale, entity, responsiveTextSize, value.map);
+            return renderOneTimeCostMap(value.Map);
         default:
             return assertExhaustive(value);
     }
 };
-const getModifiableSustainedCostTranslation = (getSkillModificationLevelById, locale, speed, entity, responsiveTextSize, value) => mapNullable(getSkillModificationLevelById(value.initial_modification_level), (modificationLevel) => {
-    const cost = getModifiableBySpeed((config) => config.cost, (config) => config.cost, speed, modificationLevel);
-    const formatCostP = formatEnergyByEntity.bind(this, locale, entity);
-    const interval = formatTimeSpan(locale, responsiveTextSize, value.interval.unit, value.interval.value);
-    return responsive(responsiveTextSize, () => `${formatCostP(cost) + locale.translate(" (casting)")} + ${formatCostP(cost / 2) + locale.translate(" per {0}", interval)}`, () => `${formatCostP(cost)} + ${formatCostP(cost / 2) + locale.translate("/{0}", interval)}`);
-}) ?? MISSING_VALUE;
-const getNonModifiableSustainedCostTranslation = (locale, entity, responsiveTextSize, value) => {
-    const formatCostP = formatEnergyByEntity.bind(this, locale, entity);
-    const per = (() => {
-        if (value.per === undefined) {
-            return { countable: "", minimumTotal: "" };
-        }
-        const countable = responsive(responsiveTextSize, (entity) => locale.translate(" per {0}", entity), (entity) => locale.translate("/{0}", entity), getResponsiveText(locale.translateMap(value.per.translations)?.countable, responsiveTextSize));
-        const minimumTotal = value.per.minimum_total !== undefined
-            ? locale.translate(", minimum of {0}", formatCostP(value.per.minimum_total))
-            : "";
-        return { countable, minimumTotal };
-    })();
-    const interval = formatTimeSpan(locale, responsiveTextSize, value.interval.unit, value.interval.value);
-    const cost = responsive(responsiveTextSize, () => `${formatCostP(value.value) + locale.translate(" (casting)")} + ${(value.is_minimum === true
-        ? locale.translate("half of the activation cost")
-        : formatCostP(value.value / 2)) +
-        per.countable +
-        locale.translate(" per {0}", interval)}`, () => `${formatCostP(value.value)} + ${(value.is_minimum === true ? "50%" : formatCostP(value.value / 2)) +
-        per.countable +
-        locale.translate("/{0}", interval)}`) + per.minimumTotal;
-    const costWrappedIfMinimum = wrapIfMinimum(locale, responsiveTextSize, value.is_minimum, cost);
-    return (costWrappedIfMinimum +
-        getNonModifiableSuffixTranslation(locale, entity, ModifiableParameter.Cost, responsiveTextSize));
+const buildSustainedCost = (activationCost, intervalCost, interval) => {
+    const activationCostWithLabel = responsiveR(() => translateR("activation").map(label => `${activationCost} (${label})`), () => Reader.of(activationCost)).thenW(identity);
+    const intervalCostWithLabel = appendIntervalToCost(interval, intervalCost);
+    return activationCostWithLabel.map2(intervalCostWithLabel, additionFormatter);
 };
+const renderModifiableSustainedCost = (value) => deriveModifiableCost(value.initial_modification_level).thenW(cost => cost === undefined
+    ? Reader.of(MISSING_VALUE)
+    : formatEnergyFnR.thenW(formatEnergy => {
+        const activationCost = formatEnergy(cost);
+        const intervalCost = formatEnergy(cost / 2);
+        return buildSustainedCost(activationCost, intervalCost, value.interval);
+    }));
+/**
+ * Returns the text for the non-modifiable cost of a sustained activatable skill.
+ */
+export const renderNonModifiableSustainedCost = (value) => formatEnergyFnR
+    .thenW(formatEnergy => {
+    const activationCost = formatEnergy(value.value);
+    const getIntervalCost = value.is_minimum === true
+        ? responsiveTranslateR("half of the activation cost", "50%")
+        : Reader.of(formatEnergy(value.value / 2));
+    return getIntervalCost.then(intervalCost => buildSustainedCost(activationCost, intervalCost, value.interval));
+})
+    .thenW(base => appendPerCountableToCostIfNeeded(value.per, base))
+    .then(base => wrapIfMinimum(value.is_minimum, base))
+    .then(base => appendNonModifiableSuffix(ModifiableParameter.Cost, base));
 /**
  * Returns the text for the cost of a sustained activatable skill.
  */
-export const getSustainedCostTranslation = (getSkillModificationLevelById, locale, speed, entity, responsiveTextSize, value) => {
-    switch (value.tag) {
+export const renderSustainedCost = (value) => {
+    switch (value.kind) {
         case "Modifiable":
-            return getModifiableSustainedCostTranslation(getSkillModificationLevelById, locale, speed, entity, responsiveTextSize, value.modifiable);
+            return renderModifiableSustainedCost(value.Modifiable);
         case "NonModifiable":
-            return getNonModifiableSustainedCostTranslation(locale, entity, responsiveTextSize, value.non_modifiable);
+            return renderNonModifiableSustainedCost(value.NonModifiable);
+        case "Map":
+            return renderSustainedCostMap(value.Map);
         default:
             return assertExhaustive(value);
     }
 };
+/**
+ * Generates the text for the cost specific to a magical action.
+ */
+export const renderMagicalActionCost = (cost) => {
+    switch (cost.kind) {
+        case "Fixed":
+            return renderNonModifiableOneTimeCost(cost.Fixed, false);
+        case "Indefinite":
+            return renderIndefiniteCost(cost.Indefinite, false);
+        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,
+                }),
+                additionalPersonValue: translate("{$value} AE", {
+                    value: cost.FirstPerson.value / 2,
+                }),
+            }));
+        case "ByPrimaryPatron":
+            return translateR("Depends on animal type").thenW(base => appendNoteIfNeeded(cost.ByPrimaryPatron?.translations, base));
+        case "All":
+            return Reader.asks(({ translate }) => cost.All.minimum === undefined
+                ? translate("All AE")
+                : translate("All AE, at least {$value} AE", {
+                    value: cost.All.minimum,
+                }));
+        case "Map":
+            return renderOneTimeCostMap(cost.Map);
+        default:
+            return assertExhaustive(cost);
+    }
+};

package/lib/entities/partial/rated/activatable/duration.d.ts

@@ -1,21 +1,44 @@
-import { DurationForOneTime, DurationForSustained } from "optolith-database-schema/types/_ActivatableSkillDuration";
-import { BlessingDuration } from "optolith-database-schema/types/Blessing";
-import { CantripDuration } from "optolith-database-schema/types/Cantrip";
-import { LocaleEnvironment } from "../../../../helpers/locale.js";
-import { ResponsiveTextSize } from "../../responsiveText.js";
+import type { CastingTimeDuringLovemaking, CheckResultBasedDuration, DurationForSustained, FixedDuration, Immediate, MusicDuration, PermanentDuration, ResponsiveText } from "optolith-database-schema/gen";
+import type { LocaleMap } from "../../../../helpers/translate.js";
+import { type StdReader } from "../../reader.js";
 /**
- * Returns the text for the duration of a one-time activatable skill.
+ * Renders a duration that is based on the result of the skill check.
  */
-export declare const getDurationForOneTimeTranslation: (locale: LocaleEnvironment, responsiveTextSize: ResponsiveTextSize, value: DurationForOneTime) => string;
+export declare const renderCheckResultBasedDuration: (value: CheckResultBasedDuration) => StdReader<string, "t" | "tm" | "rts">;
+type OneTimeDuration = {
+    kind: "Immediate";
+    Immediate?: Immediate;
+} | {
+    kind: "Permanent";
+    Permanent: PermanentDuration;
+} | {
+    kind: "Fixed";
+    Fixed: FixedDuration;
+} | {
+    kind: "CheckResultBased";
+    CheckResultBased: CheckResultBasedDuration;
+} | {
+    kind: "Indefinite";
+    Indefinite: {
+        maximum?: OneTimeDuration;
+        translations: LocaleMap<{
+            description: ResponsiveText | string;
+        }>;
+    };
+} | {
+    kind: "DuringLovemaking";
+    DuringLovemaking: CastingTimeDuringLovemaking;
+};
 /**
- * Returns the text for the duration of a sustained activatable skill.
+ * Returns the text for the duration of a one-time activatable skill.
  */
-export declare const getDurationForSustainedTranslation: (locale: LocaleEnvironment, responsiveTextSize: ResponsiveTextSize, value: DurationForSustained | undefined) => string;
+export declare const renderOneTimeDuration: (value: OneTimeDuration) => StdReader<string, "t" | "tm" | "rts">;
 /**
- * Returns the text for the duration of a cantrip.
+ * Returns the text for the duration of a sustained activatable skill.
  */
-export declare const getDurationTranslationForCantrip: (locale: LocaleEnvironment, responsiveTextSize: ResponsiveTextSize, value: CantripDuration) => string;
+export declare const renderSustainedDuration: (value: DurationForSustained | undefined) => StdReader<string, "t" | "rts">;
 /**
- * Returns the text for the duration of a blessing.
+ *  Returns the text for the duration of a musical activatable skill.
  */
-export declare const getDurationTranslationForBlessing: (locale: LocaleEnvironment, responsiveTextSize: ResponsiveTextSize, value: BlessingDuration) => string;
+export declare const renderMusicDuration: (duration: MusicDuration) => StdReader<string, "t">;
+export {};

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

@@ -1,43 +1,61 @@
+import { Reader } from "@elyukai/utils/reader";
 import { mapNullable } from "@optolith/helpers/nullable";
 import { assertExhaustive } from "@optolith/helpers/typeSafety";
-import { getResponsiveText, replaceTextIfRequested, responsive, } from "../../responsiveText.js";
-import { formatTimeSpan } from "../../units/timeSpan.js";
-import { getCheckResultBasedValueTranslation } from "./checkResultBased.js";
+import { responsiveTextR, responsiveTranslateR, translateMapR, translateR, } from "../../reader.js";
+import { replaceTextIfNeeded } from "../../responsiveText.js";
+import { formatCombinedTimeSpanR, formatTimeSpanR, } from "../../units/timeSpan.js";
+import { MISSING_VALUE } from "../../unknown.js";
+import { renderCheckResultBasedValue } from "./checkResultBased.js";
 import { wrapAsMaximum, wrapIfMaximum } from "./isMinimumMaximum.js";
 import { appendInParensIfNotEmpty } from "./parensIf.js";
-const getImmediateDurationTranslation = (locale, responsiveTextSize, value) => {
-    const text = appendInParensIfNotEmpty(mapNullable(value.maximum, (max) => {
-        const maxText = formatTimeSpan(locale, responsiveTextSize, max.unit, max.value);
-        return responsive(responsiveTextSize, () => locale.translate("no more than {0}", maxText), () => locale.translate("max. {0}", maxText));
-    }), locale.translate("Immediate"));
-    return replaceTextIfRequested("replacement", value.translations, locale.translateMap, responsiveTextSize, text);
-};
-const getPermanentDurationTranslation = (locale, responsiveTextSize, value) => replaceTextIfRequested("replacement", value.translations, locale.translateMap, responsiveTextSize, locale.translate("Permanent"));
-const getFixedDurationTranslation = (locale, responsiveTextSize, value) => {
-    const duration = formatTimeSpan(locale, responsiveTextSize, value.unit, value.value);
-    const durationWrappedIfMaximum = wrapIfMaximum(locale, responsiveTextSize, value.is_maximum, duration);
-    return replaceTextIfRequested("replacement", value.translations, locale.translateMap, responsiveTextSize, durationWrappedIfMaximum);
-};
-const getCheckResultBasedDurationTranslation = (locale, responsiveTextSize, value) => {
-    const duration = formatTimeSpan(locale, responsiveTextSize, value.unit, getCheckResultBasedValueTranslation(locale.translate, value));
-    return wrapIfMaximum(locale, responsiveTextSize, value.is_maximum, duration);
+const renderImmediateDuration = (value) => translateR("Immediate")
+    .thenW(base => mapNullable(value?.maximum, max => formatTimeSpanR(max.unit, max.value)
+    .then(wrapAsMaximum)
+    .map(maxText => appendInParensIfNotEmpty(maxText, base))) ?? Reader.of(base))
+    .thenW(text => replaceTextIfNeeded(value?.translations, text));
+const renderPermanentDuration = (value) => translateR("Permanent").thenW(text => replaceTextIfNeeded(value.translations, text));
+const renderFixedDuration = (value) => formatCombinedTimeSpanR(value)
+    .then(text => wrapIfMaximum(value.is_maximum, text))
+    .thenW(text => replaceTextIfNeeded(value.translations, text));
+/**
+ * Renders a duration that is based on the result of the skill check.
+ */
+export const renderCheckResultBasedDuration = (value) => renderCheckResultBasedValue(value)
+    .thenW(text => formatTimeSpanR(value.unit, text))
+    .then(text => wrapIfMaximum(value.is_maximum, text));
+const renderIndefiniteDuration = (value) => {
+    const { maximum, translations } = value;
+    return translateMapR(translations)
+        .thenW(translation => typeof translation?.description === "object"
+        ? responsiveTextR(translation.description)
+        : Reader.of(translation?.description ?? MISSING_VALUE))
+        .thenW(maximum === undefined
+        ? Reader.of
+        : text => 
+        // eslint-disable-next-line @typescript-eslint/no-use-before-define
+        renderOneTimeDuration(maximum).then(maximumText => translateR("{$defaultDuration}, but no more than {$maximumDuration}", {
+            defaultDuration: text,
+            maximumDuration: maximumText,
+        })));
 };
-const getIndefiniteDurationTranslation = (locale, responsiveTextSize, value) => getResponsiveText(locale.translateMap(value.translations)?.description, responsiveTextSize);
+const renderDurationDuringLovemaking = (value) => formatCombinedTimeSpanR(value);
 /**
  * Returns the text for the duration of a one-time activatable skill.
  */
-export const getDurationForOneTimeTranslation = (locale, responsiveTextSize, value) => {
-    switch (value.tag) {
+export const renderOneTimeDuration = (value) => {
+    switch (value.kind) {
         case "Immediate":
-            return getImmediateDurationTranslation(locale, responsiveTextSize, value.immediate);
+            return renderImmediateDuration(value.Immediate);
         case "Permanent":
-            return getPermanentDurationTranslation(locale, responsiveTextSize, value.permanent);
+            return renderPermanentDuration(value.Permanent);
         case "Fixed":
-            return getFixedDurationTranslation(locale, responsiveTextSize, value.fixed);
+            return renderFixedDuration(value.Fixed);
         case "CheckResultBased":
-            return getCheckResultBasedDurationTranslation(locale, responsiveTextSize, value.check_result_based);
+            return renderCheckResultBasedDuration(value.CheckResultBased);
         case "Indefinite":
-            return getIndefiniteDurationTranslation(locale, responsiveTextSize, value.indefinite);
+            return renderIndefiniteDuration(value.Indefinite);
+        case "DuringLovemaking":
+            return renderDurationDuringLovemaking(value.DuringLovemaking);
         default:
             return assertExhaustive(value);
     }
@@ -45,39 +63,32 @@ export const getDurationForOneTimeTranslation = (locale, responsiveTextSize, val
 /**
  * Returns the text for the duration of a sustained activatable skill.
  */
-export const getDurationForSustainedTranslation = (locale, responsiveTextSize, value) => value === undefined
-    ? responsive(responsiveTextSize, () => locale.translate("Sustained"), () => locale.translate("(S)"))
-    : wrapAsMaximum(locale, responsiveTextSize, formatTimeSpan(locale, responsiveTextSize, value.maximum.unit, value.maximum.value));
-const getDurationDuringLovemakingTranslation = (locale, responsiveTextSize, value) => formatTimeSpan(locale, responsiveTextSize, value.unit, value.value);
-/**
- * Returns the text for the duration of a cantrip.
- */
-export const getDurationTranslationForCantrip = (locale, responsiveTextSize, value) => {
-    switch (value.tag) {
-        case "Immediate":
-            return getImmediateDurationTranslation(locale, responsiveTextSize, value.immediate);
-        case "Fixed":
-            return getFixedDurationTranslation(locale, responsiveTextSize, value.fixed);
-        case "Indefinite":
-            return getIndefiniteDurationTranslation(locale, responsiveTextSize, value.indefinite);
-        case "DuringLovemaking":
-            return getDurationDuringLovemakingTranslation(locale, responsiveTextSize, value.during_lovemaking);
-        default:
-            return assertExhaustive(value);
-    }
-};
+export const renderSustainedDuration = (value) => value === undefined
+    ? responsiveTranslateR("Sustained", "(S)")
+    : formatCombinedTimeSpanR(value.maximum).then(maxText => wrapAsMaximum(maxText));
 /**
- * Returns the text for the duration of a blessing.
+ *  Returns the text for the duration of a musical activatable skill.
  */
-export const getDurationTranslationForBlessing = (locale, responsiveTextSize, value) => {
-    switch (value.tag) {
-        case "Immediate":
-            return getImmediateDurationTranslation(locale, responsiveTextSize, value.immediate);
-        case "Fixed":
-            return getFixedDurationTranslation(locale, responsiveTextSize, value.fixed);
-        case "Indefinite":
-            return getIndefiniteDurationTranslation(locale, responsiveTextSize, value.indefinite);
-        default:
-            return assertExhaustive(value);
-    }
-};
+export const renderMusicDuration = (duration) => Reader.asks(({ translate }) => {
+    const length = (() => {
+        switch (duration.length.kind) {
+            case "Long":
+                return translate("long");
+            case "Short":
+                return translate("short");
+            default:
+                return assertExhaustive(duration.length);
+        }
+    })();
+    const reusability = (() => {
+        switch (duration.reusability.kind) {
+            case "OneTime":
+                return translate("one-time");
+            case "Sustainable":
+                return translate("sustainable");
+            default:
+                return assertExhaustive(duration.reusability);
+        }
+    })();
+    return `${length}, ${reusability}`;
+});

package/lib/entities/partial/rated/activatable/effect.d.ts

@@ -1,7 +1,7 @@
-import { Effect } from "optolith-database-schema/types/_ActivatableSkillEffect";
-import { LocaleEnvironment } from "../../../../helpers/locale.js";
-import { EntityDescriptionSection } from "../../../../index.js";
+import type { ActivatableSkillEffect } from "optolith-database-schema/gen";
+import type { RawDefinitionListEntityDescriptionSectionItem } from "../../../../index.js";
+import { type StdReader } from "../../reader.js";
 /**
  * Gets the text for the effect of an activatable skill.
  */
-export declare const getTextForEffect: (locale: LocaleEnvironment, effect: Effect) => EntityDescriptionSection[];
+export declare const renderEffect: (effect: ActivatableSkillEffect) => StdReader<RawDefinitionListEntityDescriptionSectionItem, "t">;