@optolith/entity-descriptions 0.1.1 → 0.2.1

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

@@ -1,165 +1,148 @@
 import { mapNullable, mapNullableDefault } from "@optolith/helpers/nullable";
 import { assertExhaustive } from "@optolith/helpers/typeSafety";
-import { getResponsiveText, getResponsiveTextOptional, replaceTextIfRequested, responsive, } from "../../responsiveText.js";
+import { appendNoteIfRequested, getResponsiveText, replaceTextIfRequested, responsive, } from "../../responsiveText.js";
+import { formatEnergyByEntity } from "../../units/energy.js";
+import { formatTimeSpan } from "../../units/timeSpan.js";
 import { MISSING_VALUE } from "../../unknown.js";
-import { ModifiableParameter } from "./modifiableParameter.js";
-import { getTextForNonModifiableSuffix } from "./nonModifiable.js";
-import { getModifiableBySpeed, Speed } from "./speed.js";
-import { formatCost, formatTimeSpan } from "./units.js";
-const getTextForModifiableOneTimeCost = (deps, value, env) => mapNullable(deps.getSkillModificationLevelById(value.initial_modification_level), (modificationLevel) => {
-    const cost = getModifiableBySpeed(modificationLevel, env.speed, (config) => config.cost, (config) => config.cost);
-    return replaceTextIfRequested(value.translations, formatCost(deps.translate, env.entity, cost), deps.translateMap, env.responsiveText);
+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 getMinimumText = (isMinimum, translate, responsiveText) => isMinimum !== true
-    ? ""
-    : responsive(responsiveText, () => translate("at least "), () => translate("min. "));
-const getTextForNonModifiableOneTimeCostPerCountable = (deps, value, env) => mapNullable(value, (perCountable) => {
-    const countableText = responsive(env.responsiveText, (entity) => deps.translate(" per {0}", entity), (entity) => deps.translate("/{0}", entity), getResponsiveText(deps.translateMap(perCountable.translations)?.countable, env.responsiveText));
-    const minimumTotalText = mapNullable(perCountable.minimum_total, (minimumTotal) => deps.translate(", minimum of {0}", deps.formatCost(minimumTotal))) ?? "";
+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 getTextForPermanentValue = (value, responsiveText, translate) => value === undefined
+const getPermanentValueTranslation = (locale, responsiveTextSize, permanentValue) => permanentValue === undefined
     ? ""
-    : responsive(responsiveText, (perm) => translate(", {0} of which are permanent", perm), (perm) => translate(" ({0} perm.)", perm), value);
-const getTextForNonModifiableOneTimeCost = (deps, value, env) => {
-    const isMinimum = getMinimumText(value.is_minimum, deps.translate, env.responsiveText);
-    const formatCostP = formatCost.bind(this, deps.translate, env.entity);
-    const per = getTextForNonModifiableOneTimeCostPerCountable({ ...deps, formatCost: formatCostP }, value.per, env);
-    const permanent = getTextForPermanentValue(value.permanent_value, env.responsiveText, deps.translate);
-    const translation = deps.translateMap(value.translations);
-    const note = mapNullableDefault(translation === undefined || translation.note === undefined
-        ? undefined
-        : getResponsiveTextOptional(translation.note, env.responsiveText), (noteIfPresent) => ` (${noteIfPresent})`, "");
-    const cannotModify = getTextForNonModifiableSuffix(deps.translate, env.entity, ModifiableParameter.Cost, env.responsiveText);
-    return (isMinimum + formatCostP(value.value) + per + permanent + note + cannotModify);
+    : 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;
 };
-const getTextForIndefiniteOneTimeCost = (deps, value, env) => (getResponsiveText(deps.translateMap(value.translations)?.description, env.responsiveText) ?? "") +
-    getTextForNonModifiableSuffix(deps.translate, env.entity, ModifiableParameter.Cost, env.responsiveText);
-const getTextForSingleOneTimeCost = (deps, value, env) => {
+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) {
         case "Modifiable":
-            return getTextForModifiableOneTimeCost(deps, value.modifiable, env);
+            return getModifiableOneTimeCostTranslation(getSkillModificationLevelById, locale, responsiveTextSize, entity, speed, value.modifiable);
         case "NonModifiable":
-            return getTextForNonModifiableOneTimeCost(deps, value.non_modifiable, env);
+            return getNonModifiableOneTimeCostTranslation(locale, entity, responsiveTextSize, value.non_modifiable);
         case "Indefinite":
-            return getTextForIndefiniteOneTimeCost(deps, value.indefinite, env);
+            return getIndefiniteOneTimeCostTranslation(locale, entity, responsiveTextSize, value.indefinite);
         default:
             return assertExhaustive(value);
     }
 };
-const getTextForMultipleOneTimeCosts = (deps, value, type, env) => {
+const getMultipleOneTimeCostsTranslation = (type, getSkillModificationLevelById, locale, speed, entity, responsiveTextSize, value) => {
     const modifiable = !value.every((part) => part.tag === "Modifiable")
-        ? getTextForNonModifiableSuffix(deps.translate, env.entity, ModifiableParameter.Cost, env.responsiveText)
+        ? getNonModifiableSuffixTranslation(locale, entity, ModifiableParameter.Cost, responsiveTextSize)
         : "";
     return (value
-        .map((part) => getTextForSingleOneTimeCost(deps, part, env))
+        .map((part) => getSingleOneTimeCostTranslation(getSkillModificationLevelById, locale, speed, entity, responsiveTextSize, part))
         .join((() => {
         switch (type) {
             case "conjunction":
-                return responsive(env.responsiveText, () => deps.translate(" and "), () => deps.translate(" + "));
+                return responsive(responsiveTextSize, () => locale.translate(" and "), () => locale.translate(" + "));
             case "disjunction":
-                return responsive(env.responsiveText, () => deps.translate(" or "), () => deps.translate(" / "));
+                return responsive(responsiveTextSize, () => locale.translate(" or "), () => locale.translate(" / "));
             default:
                 return assertExhaustive(type);
         }
     })()) + modifiable);
 };
-const getTextForCostMap = (deps, value, env) => {
-    const translation = deps.translateMap(value.translations);
+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;
     }
-    const costs = value.options.map((option) => option.value).join("/");
     const labels = value.options
-        .map((option) => deps.translateMap(option.translations)?.label ?? MISSING_VALUE)
+        .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 = formatCost.bind(this, deps.translate, env.entity);
-    const notModifiable = getTextForNonModifiableSuffix(deps.translate, env.entity, ModifiableParameter.Cost, env.responsiveText);
+    const formatCostP = formatEnergyByEntity.bind(this, locale, entity);
+    const notModifiable = getNonModifiableSuffixTranslation(locale, entity, ModifiableParameter.Cost, responsiveTextSize);
     return (formatCostP(costs) +
-        deps.translate(" for ") +
+        locale.translate(" for ") +
         mapNullableDefault(translation?.list_prepend, (listPrepend) => `${listPrepend} `, "") +
         labels +
         (translation?.list_append ?? "") +
         (permanentCosts !== undefined
-            ? deps.translate(", {0} of which are permanent", formatCostP(permanentCosts))
+            ? locale.translate(", {0} of which are permanent", formatCostP(permanentCosts))
             : "") +
         notModifiable);
 };
 /**
  * Returns the text for the cost of a one-time activatable skill.
  */
-export const getTextForOneTimeCost = (deps, value, env) => {
+export const getOneTimeCostTranslation = (getSkillModificationLevelById, locale, speed, entity, responsiveTextSize, value) => {
     switch (value.tag) {
         case "Single":
-            return getTextForSingleOneTimeCost(deps, value.single, env);
+            return getSingleOneTimeCostTranslation(getSkillModificationLevelById, locale, speed, entity, responsiveTextSize, value.single);
         case "Conjunction":
-            return getTextForMultipleOneTimeCosts(deps, value.conjunction, "conjunction", env);
+            return getMultipleOneTimeCostsTranslation("conjunction", getSkillModificationLevelById, locale, speed, entity, responsiveTextSize, value.conjunction);
         case "Disjunction":
-            return getTextForMultipleOneTimeCosts(deps, value.disjunction, "disjunction", env);
+            return getMultipleOneTimeCostsTranslation("disjunction", getSkillModificationLevelById, locale, speed, entity, responsiveTextSize, value.disjunction);
         case "Map":
-            return getTextForCostMap(deps, value.map, env);
+            return getCostMapTranslation(locale, entity, responsiveTextSize, 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));
+};
 /**
  * Returns the text for the cost of a sustained activatable skill.
  */
-export const getTextForSustainedCost = (deps, value, env) => {
+export const getSustainedCostTranslation = (getSkillModificationLevelById, locale, speed, entity, responsiveTextSize, value) => {
     switch (value.tag) {
-        case "Modifiable": {
-            const modificationLevel = deps.getSkillModificationLevelById(value.modifiable.initial_modification_level);
-            if (modificationLevel === undefined) {
-                return MISSING_VALUE;
-            }
-            const cost = (() => {
-                switch (env.speed) {
-                    case Speed.Fast:
-                        return modificationLevel.fast.cost;
-                    case Speed.Slow:
-                        return modificationLevel.slow.cost;
-                    default:
-                        return assertExhaustive(env.speed);
-                }
-            })();
-            const formatCostP = formatCost.bind(this, deps.translate, env.entity);
-            const interval = formatTimeSpan(deps.translate, env.responsiveText, value.modifiable.interval.unit, value.modifiable.interval.value);
-            return responsive(env.responsiveText, () => `${formatCostP(cost) + deps.translate(" (casting)")} + ${formatCostP(cost / 2) + deps.translate(" per {0}", interval)}`, () => `${formatCostP(cost)} + ${formatCostP(cost / 2) + deps.translate("/{0}", interval)}`);
-        }
-        case "NonModifiable": {
-            const isMinimum = getMinimumText(value.non_modifiable.is_minimum, deps.translate, env.responsiveText);
-            const cost = value.non_modifiable.value;
-            const formatCostP = formatCost.bind(this, deps.translate, env.entity);
-            const per = (() => {
-                if (value.non_modifiable.per === undefined) {
-                    return { countable: "", minimumTotal: "" };
-                }
-                const countable = responsive(env.responsiveText, (entity) => deps.translate(" per {0}", entity), (entity) => deps.translate("/{0}", entity), getResponsiveText(deps.translateMap(value.non_modifiable.per.translations)?.countable, env.responsiveText));
-                const minimumTotal = value.non_modifiable.per.minimum_total !== undefined
-                    ? deps.translate(", minimum of {0}", formatCostP(value.non_modifiable.per.minimum_total))
-                    : "";
-                return { countable, minimumTotal };
-            })();
-            const interval = formatTimeSpan(deps.translate, env.responsiveText, value.non_modifiable.interval.unit, value.non_modifiable.interval.value);
-            return (isMinimum +
-                responsive(env.responsiveText, () => `${formatCostP(cost) + deps.translate(" (casting)")} + ${(value.non_modifiable.is_minimum === true
-                    ? deps.translate("half of the activation cost")
-                    : formatCostP(cost / 2)) +
-                    per.countable +
-                    deps.translate(" per {0}", interval)}`, () => `${formatCostP(cost)} + ${(value.non_modifiable.is_minimum === true
-                    ? "50%"
-                    : formatCostP(cost / 2)) +
-                    per.countable +
-                    deps.translate("/{0}", interval)}`) +
-                per.minimumTotal +
-                getTextForNonModifiableSuffix(deps.translate, env.entity, ModifiableParameter.Cost, env.responsiveText));
-        }
+        case "Modifiable":
+            return getModifiableSustainedCostTranslation(getSkillModificationLevelById, locale, speed, entity, responsiveTextSize, value.modifiable);
+        case "NonModifiable":
+            return getNonModifiableSustainedCostTranslation(locale, entity, responsiveTextSize, value.non_modifiable);
         default:
             return assertExhaustive(value);
     }

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

@@ -1,40 +1,21 @@
 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 { Translate, TranslateMap } from "../../../../helpers/translate.js";
+import { LocaleEnvironment } from "../../../../helpers/locale.js";
 import { ResponsiveTextSize } from "../../responsiveText.js";
 /**
  * Returns the text for the duration of a one-time activatable skill.
  */
-export declare const getTextForDurationForOneTime: (deps: {
-    translate: Translate;
-    translateMap: TranslateMap;
-}, value: DurationForOneTime, env: {
-    responsiveText: ResponsiveTextSize;
-}) => string;
+export declare const getDurationForOneTimeTranslation: (locale: LocaleEnvironment, responsiveTextSize: ResponsiveTextSize, value: DurationForOneTime) => string;
 /**
  * Returns the text for the duration of a sustained activatable skill.
  */
-export declare const getTextForDurationForSustained: (deps: {
-    translate: Translate;
-}, value: DurationForSustained | undefined, env: {
-    responsiveText: ResponsiveTextSize;
-}) => string;
+export declare const getDurationForSustainedTranslation: (locale: LocaleEnvironment, responsiveTextSize: ResponsiveTextSize, value: DurationForSustained | undefined) => string;
 /**
  * Returns the text for the duration of a cantrip.
  */
-export declare const getTextForCantripDuration: (deps: {
-    translate: Translate;
-    translateMap: TranslateMap;
-}, value: CantripDuration, env: {
-    responsiveText: ResponsiveTextSize;
-}) => string;
+export declare const getDurationTranslationForCantrip: (locale: LocaleEnvironment, responsiveTextSize: ResponsiveTextSize, value: CantripDuration) => string;
 /**
  * Returns the text for the duration of a blessing.
  */
-export declare const getTextForBlessingDuration: (deps: {
-    translate: Translate;
-    translateMap: TranslateMap;
-}, value: BlessingDuration, env: {
-    responsiveText: ResponsiveTextSize;
-}) => string;
+export declare const getDurationTranslationForBlessing: (locale: LocaleEnvironment, responsiveTextSize: ResponsiveTextSize, value: BlessingDuration) => string;

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

@@ -1,58 +1,43 @@
-import { mapNullableDefault } from "@optolith/helpers/nullable";
+import { mapNullable } from "@optolith/helpers/nullable";
 import { assertExhaustive } from "@optolith/helpers/typeSafety";
 import { getResponsiveText, replaceTextIfRequested, responsive, } from "../../responsiveText.js";
-import { getTextForCheckResultBased } from "./checkResultBased.js";
-import { getTextForIsMaximum } from "./isMaximum.js";
-import { formatTimeSpan } from "./units.js";
-const getTextForImmediateDuration = (deps, value, env) => {
-    const text = deps.translate("Immediate") +
-        mapNullableDefault(value.maximum, (max) => {
-            const maxText = formatTimeSpan(deps.translate, env.responsiveText, max.unit, max.value);
-            return responsive(env.responsiveText, () => deps.translate(" (no more than {0})", maxText), () => deps.translate(" (max. {0})", maxText));
-        }, "");
-    return replaceTextIfRequested(value.translations, text, deps.translateMap, env.responsiveText);
+import { formatTimeSpan } from "../../units/timeSpan.js";
+import { getCheckResultBasedValueTranslation } 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 getTextForPermanentDuration = (deps, value, env) => {
-    const translation = deps.translateMap(value.translations);
-    const text = deps.translate("Permanent");
-    if (translation?.replacement !== undefined) {
-        return getResponsiveText(translation.replacement, env.responsiveText).replace("$1", text);
-    }
-    else {
-        return text;
-    }
-};
-const getTextForFixedDuration = (deps, value, env) => {
-    const isMaximum = getTextForIsMaximum(value.is_maximum, deps.translate, env.responsiveText);
-    const unitValue = formatTimeSpan(deps.translate, env.responsiveText, value.unit, value.value);
-    const text = isMaximum + unitValue;
-    const translation = deps.translateMap(value.translations);
-    if (translation?.replacement !== undefined) {
-        return getResponsiveText(translation.replacement, env.responsiveText).replace("$1", text);
-    }
-    else {
-        return 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 getTextForCheckResultBasedDuration = (deps, value, env) => {
-    const isMaximum = getTextForIsMaximum(value.is_maximum, deps.translate, env.responsiveText);
-    return formatTimeSpan(deps.translate, env.responsiveText, value.unit, isMaximum + getTextForCheckResultBased(value, deps.translate));
+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 getIndefiniteDurationTranslation = (locale, responsiveTextSize, value) => getResponsiveText(locale.translateMap(value.translations)?.description, responsiveTextSize);
 /**
  * Returns the text for the duration of a one-time activatable skill.
  */
-export const getTextForDurationForOneTime = (deps, value, env) => {
+export const getDurationForOneTimeTranslation = (locale, responsiveTextSize, value) => {
     switch (value.tag) {
         case "Immediate":
-            return getTextForImmediateDuration(deps, value.immediate, env);
+            return getImmediateDurationTranslation(locale, responsiveTextSize, value.immediate);
         case "Permanent":
-            return getTextForPermanentDuration(deps, value.permanent, env);
+            return getPermanentDurationTranslation(locale, responsiveTextSize, value.permanent);
         case "Fixed":
-            return getTextForFixedDuration(deps, value.fixed, env);
+            return getFixedDurationTranslation(locale, responsiveTextSize, value.fixed);
         case "CheckResultBased":
-            return getTextForCheckResultBasedDuration(deps, value.check_result_based, env);
+            return getCheckResultBasedDurationTranslation(locale, responsiveTextSize, value.check_result_based);
         case "Indefinite":
-            return getResponsiveText(deps.translateMap(value.indefinite.translations)?.description, env.responsiveText);
+            return getIndefiniteDurationTranslation(locale, responsiveTextSize, value.indefinite);
         default:
             return assertExhaustive(value);
     }
@@ -60,25 +45,23 @@ export const getTextForDurationForOneTime = (deps, value, env) => {
 /**
  * Returns the text for the duration of a sustained activatable skill.
  */
-export const getTextForDurationForSustained = (deps, value, env) => value === undefined
-    ? responsive(env.responsiveText, () => deps.translate("Sustained"), () => deps.translate("(S)"))
-    : responsive(env.responsiveText, () => deps.translate("no more than "), () => deps.translate("max. ")) +
-        formatTimeSpan(deps.translate, env.responsiveText, value.maximum.unit, value.maximum.value);
+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 getTextForCantripDuration = (deps, value, env) => {
+export const getDurationTranslationForCantrip = (locale, responsiveTextSize, value) => {
     switch (value.tag) {
         case "Immediate":
-            return getTextForImmediateDuration(deps, value.immediate, env);
+            return getImmediateDurationTranslation(locale, responsiveTextSize, value.immediate);
         case "Fixed":
-            return getTextForFixedDuration(deps, value.fixed, env);
+            return getFixedDurationTranslation(locale, responsiveTextSize, value.fixed);
         case "Indefinite":
-            return getResponsiveText(deps.translateMap(value.indefinite.translations)?.description, env.responsiveText);
-        case "DuringLovemaking": {
-            const { value: lovemakingValue, unit: lovemakingUnit } = value.during_lovemaking;
-            return formatTimeSpan(deps.translate, env.responsiveText, lovemakingUnit, lovemakingValue);
-        }
+            return getIndefiniteDurationTranslation(locale, responsiveTextSize, value.indefinite);
+        case "DuringLovemaking":
+            return getDurationDuringLovemakingTranslation(locale, responsiveTextSize, value.during_lovemaking);
         default:
             return assertExhaustive(value);
     }
@@ -86,14 +69,14 @@ export const getTextForCantripDuration = (deps, value, env) => {
 /**
  * Returns the text for the duration of a blessing.
  */
-export const getTextForBlessingDuration = (deps, value, env) => {
+export const getDurationTranslationForBlessing = (locale, responsiveTextSize, value) => {
     switch (value.tag) {
         case "Immediate":
-            return getTextForImmediateDuration(deps, value.immediate, env);
+            return getImmediateDurationTranslation(locale, responsiveTextSize, value.immediate);
         case "Fixed":
-            return getTextForFixedDuration(deps, value.fixed, env);
+            return getFixedDurationTranslation(locale, responsiveTextSize, value.fixed);
         case "Indefinite":
-            return getResponsiveText(deps.translateMap(value.indefinite.translations)?.description, env.responsiveText);
+            return getIndefiniteDurationTranslation(locale, responsiveTextSize, value.indefinite);
         default:
             return assertExhaustive(value);
     }

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

@@ -1,7 +1,7 @@
 import { Effect } from "optolith-database-schema/types/_ActivatableSkillEffect";
-import { Translate } from "../../../../helpers/translate.js";
-import { LibraryEntryContent } from "../../../../libraryEntry.js";
+import { LocaleEnvironment } from "../../../../helpers/locale.js";
+import { EntityDescriptionSection } from "../../../../index.js";
 /**
  * Gets the text for the effect of an activatable skill.
  */
-export declare const getTextForEffect: (effect: Effect, translate: Translate) => LibraryEntryContent[];
+export declare const getTextForEffect: (locale: LocaleEnvironment, effect: Effect) => EntityDescriptionSection[];

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

@@ -1,14 +1,14 @@
 import { filterNonNullable } from "@optolith/helpers/array";
 import { mapNullable } from "@optolith/helpers/nullable";
 import { assertExhaustive } from "@optolith/helpers/typeSafety";
-const getContentPartsForQualityLevels = (source, getQualityLevelString, translate) => filterNonNullable([
+const getContentPartsForQualityLevels = (getQualityLevelString, locale, source) => filterNonNullable([
     {
-        label: translate("Effect"),
+        label: locale.translate("Effect"),
         value: source.text_before,
     },
     ...source.quality_levels.map((text, index) => ({
         value: text,
-        label: translate("QL {0}", getQualityLevelString(index)),
+        label: locale.translate("QL {0}", getQualityLevelString(index)),
     })),
     mapNullable(source.text_after, (textAfter) => ({
         value: textAfter,
@@ -18,19 +18,19 @@ const getContentPartsForQualityLevels = (source, getQualityLevelString, translat
 /**
  * Gets the text for the effect of an activatable skill.
  */
-export const getTextForEffect = (effect, translate) => {
+export const getTextForEffect = (locale, effect) => {
     switch (effect.tag) {
         case "Plain":
             return [
                 {
-                    label: translate("Effect"),
+                    label: locale.translate("Effect"),
                     value: effect.plain.text,
                 },
             ];
         case "ForEachQualityLevel":
-            return getContentPartsForQualityLevels(effect.for_each_quality_level, (index) => index + 1, translate);
+            return getContentPartsForQualityLevels((index) => index + 1, locale, effect.for_each_quality_level);
         case "ForEachTwoQualityLevels":
-            return getContentPartsForQualityLevels(effect.for_each_two_quality_levels, (index) => `${index * 2 + 1}–${index * 2 + 2}`, translate);
+            return getContentPartsForQualityLevels((index) => `${index * 2 + 1}–${index * 2 + 2}`, locale, effect.for_each_two_quality_levels);
         default:
             return assertExhaustive(effect);
     }

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

@@ -1,19 +1,12 @@
 import { FastOneTimePerformanceParameters, FastSustainedPerformanceParameters, SlowOneTimePerformanceParameters, SlowSustainedPerformanceParameters } from "optolith-database-schema/types/_ActivatableSkill";
 import { GetById } from "../../../../helpers/getTypes.js";
-import { Translate, TranslateMap } from "../../../../helpers/translate.js";
+import { LocaleEnvironment } from "../../../../helpers/locale.js";
 import { ResponsiveTextSize } from "../../responsiveText.js";
 import { Entity } from "./entity.js";
 /**
  * Get the texts for all fast one-time performance parameters.
  */
-export declare const getTextForFastOneTimePerformanceParameters: (deps: {
-    getSkillModificationLevelById: GetById.Static.SkillModificationLevel;
-    translate: Translate;
-    translateMap: TranslateMap;
-}, value: FastOneTimePerformanceParameters, env: {
-    entity: Entity;
-    responsiveText: ResponsiveTextSize;
-}) => {
+export declare const getFastOneTimePerformanceParametersTranslations: (getSkillModificationLevelById: GetById.Static.SkillModificationLevel, locale: LocaleEnvironment, entity: Entity, responsiveTextSize: ResponsiveTextSize, value: FastOneTimePerformanceParameters) => {
     castingTime: string;
     cost: string;
     range: string;
@@ -22,14 +15,7 @@ export declare const getTextForFastOneTimePerformanceParameters: (deps: {
 /**
  * Get the texts for all fast sustained performance parameters.
  */
-export declare const getTextForFastSustainedPerformanceParameters: (deps: {
-    getSkillModificationLevelById: GetById.Static.SkillModificationLevel;
-    translate: Translate;
-    translateMap: TranslateMap;
-}, value: FastSustainedPerformanceParameters, env: {
-    entity: Entity;
-    responsiveText: ResponsiveTextSize;
-}) => {
+export declare const getFastSustainedPerformanceParametersTranslations: (getSkillModificationLevelById: GetById.Static.SkillModificationLevel, locale: LocaleEnvironment, entity: Entity, responsiveTextSize: ResponsiveTextSize, value: FastSustainedPerformanceParameters) => {
     castingTime: string;
     cost: string;
     range: string;
@@ -38,14 +24,7 @@ export declare const getTextForFastSustainedPerformanceParameters: (deps: {
 /**
  * Get the texts for all slow one-time performance parameters.
  */
-export declare const getTextForSlowOneTimePerformanceParameters: (deps: {
-    getSkillModificationLevelById: GetById.Static.SkillModificationLevel;
-    translate: Translate;
-    translateMap: TranslateMap;
-}, value: SlowOneTimePerformanceParameters, env: {
-    entity: Entity;
-    responsiveText: ResponsiveTextSize;
-}) => {
+export declare const getSlowOneTimePerformanceParametersTranslations: (getSkillModificationLevelById: GetById.Static.SkillModificationLevel, locale: LocaleEnvironment, entity: Entity, responsiveTextSize: ResponsiveTextSize, value: SlowOneTimePerformanceParameters) => {
     castingTime: string;
     cost: string;
     range: string;
@@ -54,14 +33,7 @@ export declare const getTextForSlowOneTimePerformanceParameters: (deps: {
 /**
  * Get the texts for all slow sustained performance parameters.
  */
-export declare const getTextForSlowSustainedPerformanceParameters: (deps: {
-    getSkillModificationLevelById: GetById.Static.SkillModificationLevel;
-    translate: Translate;
-    translateMap: TranslateMap;
-}, value: SlowSustainedPerformanceParameters, env: {
-    entity: Entity;
-    responsiveText: ResponsiveTextSize;
-}) => {
+export declare const getSlowSustainedPerformanceParametersTranslations: (getSkillModificationLevelById: GetById.Static.SkillModificationLevel, locale: LocaleEnvironment, entity: Entity, responsiveTextSize: ResponsiveTextSize, value: SlowSustainedPerformanceParameters) => {
     castingTime: string;
     cost: string;
     range: string;