@optolith/entity-descriptions 0.2.0 → 0.3.1

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

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

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

@@ -1,41 +1,45 @@
-import { FastOneTimePerformanceParameters, FastSustainedPerformanceParameters, SlowOneTimePerformanceParameters, SlowSustainedPerformanceParameters } from "optolith-database-schema/types/_ActivatableSkill";
-import { GetById } from "../../../../helpers/getTypes.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 getFastOneTimePerformanceParametersTranslations: (getSkillModificationLevelById: GetById.Static.SkillModificationLevel, locale: LocaleEnvironment, entity: Entity, responsiveTextSize: ResponsiveTextSize, value: FastOneTimePerformanceParameters) => {
+import type { FastOneTimePerformanceParameters, FastSustainedPerformanceParameters, OneTimePerformanceParameters, SlowOneTimePerformanceParameters, SlowSustainedPerformanceParameters } from "optolith-database-schema/gen";
+import type { StdReader } from "../../reader.js";
+type RenderedPerformanceParameters = {
     castingTime: string;
     cost: string;
     range: string;
     duration: string;
 };
+/**
+ * Get the texts for all fast one-time performance parameters.
+ */
+export declare const renderFastOneTimePerformanceParameters: (value: FastOneTimePerformanceParameters) => StdReader<RenderedPerformanceParameters, "t" | "tm" | "lj" | "eu" | "rts" | "nms" | "ibi", "SkillModificationLevel">;
 /**
  * Get the texts for all fast sustained performance parameters.
  */
-export declare const getFastSustainedPerformanceParametersTranslations: (getSkillModificationLevelById: GetById.Static.SkillModificationLevel, locale: LocaleEnvironment, entity: Entity, responsiveTextSize: ResponsiveTextSize, value: FastSustainedPerformanceParameters) => {
-    castingTime: string;
-    cost: string;
-    range: string;
-    duration: string;
-};
+export declare const renderFastSustainedPerformanceParameters: (value: FastSustainedPerformanceParameters) => StdReader<RenderedPerformanceParameters, "t" | "tm" | "lj" | "eu" | "rts" | "nms" | "ibi", "SkillModificationLevel">;
+/**
+ * Renders the performance parameters for a fast activatable skill.
+ */
+export declare const renderFastPerformanceParameters: (value: {
+    kind: "OneTime";
+    OneTime: FastOneTimePerformanceParameters;
+} | {
+    kind: "Sustained";
+    Sustained: FastSustainedPerformanceParameters;
+}) => StdReader<RenderedPerformanceParameters, "t" | "tm" | "lj" | "eu" | "rts" | "nms" | "ibi", "SkillModificationLevel">;
 /**
  * Get the texts for all slow one-time performance parameters.
  */
-export declare const getSlowOneTimePerformanceParametersTranslations: (getSkillModificationLevelById: GetById.Static.SkillModificationLevel, locale: LocaleEnvironment, entity: Entity, responsiveTextSize: ResponsiveTextSize, value: SlowOneTimePerformanceParameters) => {
-    castingTime: string;
-    cost: string;
-    range: string;
-    duration: string;
-};
+export declare const renderSlowOneTimePerformanceParameters: <CastingTime>(renderCastingTime: (value: CastingTime) => StdReader<string, "t" | "rts" | "nms" | "ibi", "SkillModificationLevel">, value: OneTimePerformanceParameters<CastingTime>) => StdReader<RenderedPerformanceParameters, "t" | "tm" | "lj" | "eu" | "rts" | "nms" | "ibi", "SkillModificationLevel">;
 /**
  * Get the texts for all slow sustained performance parameters.
  */
-export declare const getSlowSustainedPerformanceParametersTranslations: (getSkillModificationLevelById: GetById.Static.SkillModificationLevel, locale: LocaleEnvironment, entity: Entity, responsiveTextSize: ResponsiveTextSize, value: SlowSustainedPerformanceParameters) => {
-    castingTime: string;
-    cost: string;
-    range: string;
-    duration: string;
-};
+export declare const renderSlowSustainedPerformanceParameters: (value: SlowSustainedPerformanceParameters) => StdReader<RenderedPerformanceParameters, "t" | "tm" | "lj" | "eu" | "rts" | "nms" | "ibi", "SkillModificationLevel">;
+/**
+ * Renders the performance parameters for a slow activatable skill.
+ */
+export declare const renderSlowPerformanceParameters: (value: {
+    kind: "OneTime";
+    OneTime: SlowOneTimePerformanceParameters;
+} | {
+    kind: "Sustained";
+    Sustained: SlowSustainedPerformanceParameters;
+}) => StdReader<RenderedPerformanceParameters, "t" | "tm" | "lj" | "eu" | "rts" | "nms" | "ibi", "SkillModificationLevel">;
+export {};

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

@@ -1,41 +1,76 @@
-import { getFastCastingTimeTranslation, getSlowCastingTimeTranslation, } from "./castingTime.js";
-import { getOneTimeCostTranslation, getSustainedCostTranslation, } from "./cost.js";
-import { getDurationForOneTimeTranslation, getDurationForSustainedTranslation, } from "./duration.js";
-import { getTextForActivatableSkillRange } from "./range.js";
+import { assertExhaustive } from "@elyukai/utils/typeSafety";
+import { renderFastCastingTime, renderSlowCastingTime } from "./castingTime.js";
+import { renderOneTimeCost, renderSustainedCost } from "./cost.js";
+import { renderOneTimeDuration, renderSustainedDuration } from "./duration.js";
+import { renderRange } from "./range.js";
 import { Speed } from "./speed.js";
 /**
  * Get the texts for all fast one-time performance parameters.
  */
-export const getFastOneTimePerformanceParametersTranslations = (getSkillModificationLevelById, locale, entity, responsiveTextSize, value) => ({
-    castingTime: getFastCastingTimeTranslation(getSkillModificationLevelById, locale, entity, responsiveTextSize, value.casting_time),
-    cost: getOneTimeCostTranslation(getSkillModificationLevelById, locale, Speed.Fast, entity, responsiveTextSize, value.cost),
-    range: getTextForActivatableSkillRange(getSkillModificationLevelById, locale, Speed.Fast, responsiveTextSize, entity, value.range),
-    duration: getDurationForOneTimeTranslation(locale, responsiveTextSize, value.duration),
-});
+export const renderFastOneTimePerformanceParameters = (value) => renderFastCastingTime(value.casting_time)
+    .thenW(castingTime => renderOneTimeCost(value.cost).then(cost => renderRange(value.range).then(range => renderOneTimeDuration(value.duration).map(duration => ({
+    castingTime,
+    cost,
+    range,
+    duration,
+})))))
+    .with(env => ({ ...env, speed: Speed.Fast }));
 /**
  * Get the texts for all fast sustained performance parameters.
  */
-export const getFastSustainedPerformanceParametersTranslations = (getSkillModificationLevelById, locale, entity, responsiveTextSize, value) => ({
-    castingTime: getFastCastingTimeTranslation(getSkillModificationLevelById, locale, entity, responsiveTextSize, value.casting_time),
-    cost: getSustainedCostTranslation(getSkillModificationLevelById, locale, Speed.Fast, entity, responsiveTextSize, value.cost),
-    range: getTextForActivatableSkillRange(getSkillModificationLevelById, locale, Speed.Fast, responsiveTextSize, entity, value.range),
-    duration: getDurationForSustainedTranslation(locale, responsiveTextSize, value.duration),
-});
+export const renderFastSustainedPerformanceParameters = (value) => renderFastCastingTime(value.casting_time)
+    .thenW(castingTime => renderSustainedCost(value.cost).then(cost => renderRange(value.range).then(range => renderSustainedDuration(value.duration).map(duration => ({
+    castingTime,
+    cost,
+    range,
+    duration,
+})))))
+    .with(env => ({ ...env, speed: Speed.Fast }));
+/**
+ * Renders the performance parameters for a fast activatable skill.
+ */
+export const renderFastPerformanceParameters = (value) => {
+    switch (value.kind) {
+        case "OneTime":
+            return renderFastOneTimePerformanceParameters(value.OneTime);
+        case "Sustained":
+            return renderFastSustainedPerformanceParameters(value.Sustained);
+        default:
+            return assertExhaustive(value);
+    }
+};
 /**
  * Get the texts for all slow one-time performance parameters.
  */
-export const getSlowOneTimePerformanceParametersTranslations = (getSkillModificationLevelById, locale, entity, responsiveTextSize, value) => ({
-    castingTime: getSlowCastingTimeTranslation(getSkillModificationLevelById, locale, entity, responsiveTextSize, value.casting_time),
-    cost: getOneTimeCostTranslation(getSkillModificationLevelById, locale, Speed.Slow, entity, responsiveTextSize, value.cost),
-    range: getTextForActivatableSkillRange(getSkillModificationLevelById, locale, Speed.Slow, responsiveTextSize, entity, value.range),
-    duration: getDurationForOneTimeTranslation(locale, responsiveTextSize, value.duration),
-});
+export const renderSlowOneTimePerformanceParameters = (renderCastingTime, value) => renderCastingTime(value.casting_time)
+    .thenW(castingTime => renderOneTimeCost(value.cost).then(cost => renderRange(value.range).then(range => renderOneTimeDuration(value.duration).map(duration => ({
+    castingTime,
+    cost,
+    range,
+    duration,
+})))))
+    .with(env => ({ ...env, speed: Speed.Slow }));
 /**
  * Get the texts for all slow sustained performance parameters.
  */
-export const getSlowSustainedPerformanceParametersTranslations = (getSkillModificationLevelById, locale, entity, responsiveTextSize, value) => ({
-    castingTime: getSlowCastingTimeTranslation(getSkillModificationLevelById, locale, entity, responsiveTextSize, value.casting_time),
-    cost: getSustainedCostTranslation(getSkillModificationLevelById, locale, Speed.Slow, entity, responsiveTextSize, value.cost),
-    range: getTextForActivatableSkillRange(getSkillModificationLevelById, locale, Speed.Slow, responsiveTextSize, entity, value.range),
-    duration: getDurationForSustainedTranslation(locale, responsiveTextSize, value.duration),
-});
+export const renderSlowSustainedPerformanceParameters = (value) => renderSlowCastingTime(value.casting_time)
+    .thenW(castingTime => renderSustainedCost(value.cost).then(cost => renderRange(value.range).then(range => renderSustainedDuration(value.duration).map(duration => ({
+    castingTime,
+    cost,
+    range,
+    duration,
+})))))
+    .with(env => ({ ...env, speed: Speed.Slow }));
+/**
+ * Renders the performance parameters for a slow activatable skill.
+ */
+export const renderSlowPerformanceParameters = (value) => {
+    switch (value.kind) {
+        case "OneTime":
+            return renderSlowOneTimePerformanceParameters(renderSlowCastingTime, value.OneTime);
+        case "Sustained":
+            return renderSlowSustainedPerformanceParameters(value.Sustained);
+        default:
+            return assertExhaustive(value);
+    }
+};

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

@@ -1,20 +1,19 @@
-import { LocaleEnvironment } from "../../../../helpers/locale.js";
-import { ResponsiveTextSize } from "../../responsiveText.js";
+import { type StdReader } from "../../reader.js";
 /**
  * Wraps the text in a translation that indicates it’s a minimum value.
  */
-export declare const wrapAsMinimum: (locale: LocaleEnvironment, responsiveTextSize: ResponsiveTextSize, text: string) => string;
+export declare const wrapAsMinimum: (text: string) => StdReader<string, "t" | "rts">;
 /**
  * Wraps the text in a translation that indicates it’s a minimum value if the
  * `is_minimum` property says it’s a minimum value.
  */
-export declare const wrapIfMinimum: (locale: LocaleEnvironment, responsiveTextSize: ResponsiveTextSize, is_minimum: boolean | undefined, text: string) => string;
+export declare const wrapIfMinimum: (is_minimum: boolean | undefined, text: string) => StdReader<string, "t" | "rts">;
 /**
  * Wraps the text in a translation that indicates it’s a maximum value.
  */
-export declare const wrapAsMaximum: (locale: LocaleEnvironment, responsiveTextSize: ResponsiveTextSize, text: string) => string;
+export declare const wrapAsMaximum: (text: string) => StdReader<string, "t" | "rts">;
 /**
  * Wraps the text in a translation that indicates it’s a maximum value if the
  * `is_maximum` property says it’s a maximum value.
  */
-export declare const wrapIfMaximum: (locale: LocaleEnvironment, responsiveTextSize: ResponsiveTextSize, is_maximum: boolean | undefined, text: string) => string;
+export declare const wrapIfMaximum: (is_maximum: boolean | undefined, text: string) => StdReader<string, "t" | "rts">;

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

@@ -1,19 +1,22 @@
-import { responsive } from "../../responsiveText.js";
+import { Reader } from "@elyukai/utils/reader";
+import { responsiveTranslateR } from "../../reader.js";
 /**
  * Wraps the text in a translation that indicates it’s a minimum value.
  */
-export const wrapAsMinimum = (locale, responsiveTextSize, text) => responsive(responsiveTextSize, () => locale.translate("at least {0}", text), () => locale.translate("min. {0}", text));
+export const wrapAsMinimum = (text) => responsiveTranslateR("at least {$value}", "min. {$value}", { value: text });
 /**
  * Wraps the text in a translation that indicates it’s a minimum value if the
  * `is_minimum` property says it’s a minimum value.
  */
-export const wrapIfMinimum = (locale, responsiveTextSize, is_minimum, text) => is_minimum === true ? wrapAsMinimum(locale, responsiveTextSize, text) : "";
+export const wrapIfMinimum = (is_minimum, text) => is_minimum === true ? wrapAsMinimum(text) : Reader.of("");
 /**
  * Wraps the text in a translation that indicates it’s a maximum value.
  */
-export const wrapAsMaximum = (locale, responsiveTextSize, text) => responsive(responsiveTextSize, () => locale.translate("no more than {0}", text), () => locale.translate("max. {0}", text));
+export const wrapAsMaximum = (text) => responsiveTranslateR("no more than {$value}", "max. {$value}", {
+    value: text,
+});
 /**
  * Wraps the text in a translation that indicates it’s a maximum value if the
  * `is_maximum` property says it’s a maximum value.
  */
-export const wrapIfMaximum = (locale, responsiveTextSize, is_maximum, text) => is_maximum === true ? wrapAsMaximum(locale, responsiveTextSize, text) : "";
+export const wrapIfMaximum = (is_maximum, text) => is_maximum === true ? wrapAsMaximum(text) : Reader.of("");

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

@@ -1,6 +1,4 @@
-import { LocaleEnvironment } from "../../../../helpers/locale.js";
-import { ResponsiveTextSize } from "../../responsiveText.js";
-import { Entity } from "./entity.js";
+import { type StdReader } from "../../reader.js";
 /**
  * A parameter that is designed to be modifiable.
  */
@@ -13,4 +11,4 @@ export declare enum ModifiableParameter {
  * Returns the suffix for the text of a non-modifiable parameter that indicates
  * that the parameter cannot be modified.
  */
-export declare const getNonModifiableSuffixTranslation: (locale: LocaleEnvironment, entity: Entity, param: ModifiableParameter, responsiveTextSize: ResponsiveTextSize) => string;
+export declare const appendNonModifiableSuffix: (param: ModifiableParameter, base: string) => StdReader<string, "t" | "rts" | "nms">;

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

@@ -1,7 +1,5 @@
-import { mapNullable } from "@optolith/helpers/nullable";
-import { assertExhaustive } from "@optolith/helpers/typeSafety";
-import { responsive } from "../../responsiveText.js";
-import { Entity } from "./entity.js";
+import { Reader } from "@elyukai/utils/reader";
+import { responsiveTranslateR, } from "../../reader.js";
 /**
  * A parameter that is designed to be modifiable.
  */
@@ -11,45 +9,12 @@ export var ModifiableParameter;
     ModifiableParameter[ModifiableParameter["Cost"] = 1] = "Cost";
     ModifiableParameter[ModifiableParameter["Range"] = 2] = "Range";
 })(ModifiableParameter || (ModifiableParameter = {}));
-const translationKeyForNonModifiableSuffix = {
-    [Entity.Spell]: {
-        [ModifiableParameter.CastingTime]: " (you cannot use a modification on this spell’s casting time)",
-        [ModifiableParameter.Cost]: " (you cannot use a modification on this spell’s cost)",
-        [ModifiableParameter.Range]: " (you cannot use a modification on this spell’s range)",
-    },
-    [Entity.Ritual]: {
-        [ModifiableParameter.CastingTime]: " (you cannot use a modification on this ritual’s ritual time)",
-        [ModifiableParameter.Cost]: " (you cannot use a modification on this ritual’s cost)",
-        [ModifiableParameter.Range]: " (you cannot use a modification on this ritual’s range)",
-    },
-    [Entity.LiturgicalChant]: {
-        [ModifiableParameter.CastingTime]: " (you cannot use a modification on this chant’s liturgical time)",
-        [ModifiableParameter.Cost]: " (you cannot use a modification on this chant’s cost)",
-        [ModifiableParameter.Range]: " (you cannot use a modification on this chant’s range)",
-    },
-    [Entity.Ceremony]: {
-        [ModifiableParameter.CastingTime]: " (you cannot use a modification on this ceremony’s ceremonial time)",
-        [ModifiableParameter.Cost]: " (you cannot use a modification on this ceremony’s cost)",
-        [ModifiableParameter.Range]: " (you cannot use a modification on this ceremony’s range)",
-    },
-    [Entity.Cantrip]: undefined,
-    [Entity.Blessing]: undefined,
-};
 /**
  * Returns the suffix for the text of a non-modifiable parameter that indicates
  * that the parameter cannot be modified.
  */
-export const getNonModifiableSuffixTranslation = (locale, entity, param, responsiveTextSize) => responsive(responsiveTextSize, () => mapNullable(translationKeyForNonModifiableSuffix[entity]?.[param], (key) => locale.translate(key)) ?? "", () => {
-    switch (entity) {
-        case Entity.Spell:
-        case Entity.Ritual:
-        case Entity.LiturgicalChant:
-        case Entity.Ceremony:
-            return locale.translate(" (cannot modify)");
-        case Entity.Cantrip:
-        case Entity.Blessing:
-            return "";
-        default:
-            return assertExhaustive(entity);
-    }
-});
+export const appendNonModifiableSuffix = (param, base) => Reader.asks((ctx) => ctx.nonModifiableSuffix)
+    .thenW(suffix => suffix === undefined
+    ? Reader.of("")
+    : responsiveTranslateR(suffix(param), " (cannot modify)"))
+    .map(suffix => base + suffix);

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

@@ -1,20 +1,28 @@
-import { Range } from "optolith-database-schema/types/_ActivatableSkillRange";
-import { BlessingRange } from "optolith-database-schema/types/Blessing";
-import { CantripRange } from "optolith-database-schema/types/Cantrip";
-import { GetById } from "../../../../helpers/getTypes.js";
-import { LocaleEnvironment } from "../../../../helpers/locale.js";
-import { ResponsiveTextSize } from "../../responsiveText.js";
-import { Entity } from "./entity.js";
-import { Speed } from "./speed.js";
+import type { CheckResultBasedRange, FixedRange, Range, RangeValue } from "optolith-database-schema/gen";
+import { type StdReader } from "../../reader.js";
 /**
- * Returns the text for the range of an activatable skill.
+ * Returns the text for the non-modifiable range of an activatable skill.
  */
-export declare const getTextForActivatableSkillRange: (getSkillModificationLevelById: GetById.Static.SkillModificationLevel, locale: LocaleEnvironment, speed: Speed, responsiveTextSize: ResponsiveTextSize, entity: Entity, value: Range) => string;
+export declare const renderNonModifiableRange: (value: {
+    kind: "Sight";
+} | {
+    kind: "Self";
+} | {
+    kind: "Global";
+} | {
+    kind: "Touch";
+} | {
+    kind: "Fixed";
+    Fixed: FixedRange;
+} | {
+    kind: "CheckResultBased";
+    CheckResultBased: CheckResultBasedRange;
+}, shouldAppendNonModifiableSuffix: boolean) => StdReader<string, "t" | "tm" | "rts" | "nms">;
 /**
- * Returns the text for the range of a cantrip.
+ * Returns the text for the range of an activatable skill.
  */
-export declare const getTextForCantripRange: (locale: LocaleEnvironment, responsiveTextSize: ResponsiveTextSize, value: CantripRange) => string;
+export declare const renderRangeValue: (value: RangeValue, shouldAppendNonModifiableSuffix: boolean) => StdReader<string, "t" | "tm" | "rts" | "s" | "nms" | "ibi", "SkillModificationLevel">;
 /**
- * Returns the text for the range of a blessing.
+ * Returns the text for the range of an activatable skill.
  */
-export declare const getTextForBlessingRange: (locale: LocaleEnvironment, responsiveTextSize: ResponsiveTextSize, value: BlessingRange) => string;
+export declare const renderRange: (value: Range) => StdReader<string, "t" | "tm" | "rts" | "s" | "nms" | "ibi", "SkillModificationLevel">;

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

@@ -1,52 +1,56 @@
+import { Reader } from "@elyukai/utils/reader";
 import { mapNullable } from "@optolith/helpers/nullable";
 import { assertExhaustive } from "@optolith/helpers/typeSafety";
-import { appendNoteIfRequested, replaceTextIfRequested, } from "../../responsiveText.js";
-import { formatLength } from "../../units/length.js";
+import { getInstanceByIdFnR, modifiableBySpeedOptionalR, modifiableBySpeedR, translateFnR, translateMapR, translateR, } from "../../reader.js";
+import { appendNoteIfNeeded, replaceTextIfNeeded, } from "../../responsiveText.js";
+import { formatCombinedLengthR, formatLengthR } from "../../units/length.js";
 import { MISSING_VALUE } from "../../unknown.js";
-import { getCheckResultBasedValueTranslation } from "./checkResultBased.js";
-import { Entity } from "./entity.js";
+import { renderCheckResultBasedValue } from "./checkResultBased.js";
 import { wrapIfMaximum } from "./isMinimumMaximum.js";
-import { getNonModifiableSuffixTranslation, ModifiableParameter, } from "./nonModifiableSuffix.js";
-import { getModifiableBySpeed } from "./speed.js";
-const getModifiableRangeTranslation = (getSkillModificationLevelById, locale, speed, responsiveTextSize, value) => mapNullable(getSkillModificationLevelById(value.initial_modification_level), (modificationLevel) => {
-    const range = getModifiableBySpeed((config) => config.range, (config) => config.range, speed, modificationLevel);
-    if (range === 1) {
-        return locale.translate("Touch");
-    }
-    return formatLength(locale, responsiveTextSize, "Steps", range);
-}) ?? MISSING_VALUE;
-const getSightTranslation = (locale) => locale.translate("Sight");
-const getSelfTranslation = (locale) => locale.translate("Self");
-const getGlobalTranslation = (locale) => locale.translate("Global");
-const getTouchTranslation = (locale, entity, responsiveTextSize) => locale.translate("Touch") +
-    getNonModifiableSuffixTranslation(locale, entity, ModifiableParameter.Range, responsiveTextSize);
-const getFixedRangeTranslation = (locale, entity, responsiveTextSize, value) => formatLength(locale, responsiveTextSize, value.unit, value.value) +
-    getNonModifiableSuffixTranslation(locale, entity, ModifiableParameter.Range, responsiveTextSize);
-const wrapIfRadius = (locale, is_radius, text) => (is_radius === true ? `${text} ${locale.translate("Radius")}` : text);
-const getCheckResultBasedRangeTranslation = (locale, entity, responsiveTextSize, value) => {
-    const range = formatLength(locale, responsiveTextSize, value.unit, getCheckResultBasedValueTranslation(locale.translate, value));
-    const rangeWrappedIfRadius = wrapIfRadius(locale, value.is_radius, range);
-    const rangeWrappedIfRadiusAndIfMaximum = wrapIfMaximum(locale, responsiveTextSize, value.is_maximum, rangeWrappedIfRadius);
-    return (rangeWrappedIfRadiusAndIfMaximum +
-        getNonModifiableSuffixTranslation(locale, entity, ModifiableParameter.Range, responsiveTextSize));
-};
-const getRangeValueTranslation = (getSkillModificationLevelById, locale, speed, responsiveTextSize, entity, value) => {
-    switch (value.tag) {
-        case "Modifiable":
-            return getModifiableRangeTranslation(getSkillModificationLevelById, locale, speed, responsiveTextSize, value.modifiable);
+import { appendNonModifiableSuffix, ModifiableParameter, } from "./nonModifiableSuffix.js";
+const deriveModifiableRange = (modificationLevelId) => getInstanceByIdFnR().thenW(getInstanceById => mapNullable(getInstanceById("SkillModificationLevel", modificationLevelId), modificationLevel => modifiableBySpeedR("range", modificationLevel).thenW(value => translateMapR(modificationLevel.translations).thenW(translation => translation === undefined
+    ? Reader.of({ value, translation: undefined })
+    : modifiableBySpeedOptionalR("range", translation).map(valueTranslation => ({
+        value,
+        translation: valueTranslation,
+    }))))) ?? Reader.of(undefined));
+const wrapIfRadius = (is_radius, text) => translateFnR.map(translate => is_radius === true ? `${text} ${translate("Radius")}` : text);
+const renderModifiableRange = (value) => deriveModifiableRange(value.initial_modification_level)
+    .thenW(range => range === undefined
+    ? Reader.of(MISSING_VALUE)
+    : typeof range === "string"
+        ? Reader.of(range)
+        : formatLengthR("Steps", range.value))
+    .then(text => wrapIfRadius(value.is_radius, text))
+    .then(text => wrapIfMaximum(value.is_maximum, text));
+const renderFixedRange = (value) => formatCombinedLengthR(value)
+    .then(text => wrapIfRadius(value.is_radius, text))
+    .then(text => wrapIfMaximum(value.is_maximum, text));
+const getCheckResultBasedRangeTranslation = (value) => renderCheckResultBasedValue(value)
+    .thenW(text => formatLengthR(value.unit, text))
+    .then(text => wrapIfRadius(value.is_radius, text))
+    .then(text => wrapIfMaximum(value.is_maximum, text));
+/**
+ * Returns the text for the non-modifiable range of an activatable skill.
+ */
+export const renderNonModifiableRange = (value, shouldAppendNonModifiableSuffix) => {
+    const appendNonModifiableSuffixIfNeeded = shouldAppendNonModifiableSuffix
+        ? (text) => appendNonModifiableSuffix(ModifiableParameter.Range, text)
+        : Reader.of;
+    switch (value.kind) {
         case "Sight":
-            return getSightTranslation(locale);
+            return translateR("Sight");
         case "Self":
-            return getSelfTranslation(locale);
+            return translateR("Self");
         case "Global":
-            return getGlobalTranslation(locale);
+            return translateR("Global");
         case "Touch":
-            return getTouchTranslation(locale, entity, responsiveTextSize);
+            return translateR("Touch").thenW(appendNonModifiableSuffixIfNeeded);
         case "Fixed": {
-            return getFixedRangeTranslation(locale, entity, responsiveTextSize, value.fixed);
+            return renderFixedRange(value.Fixed).thenW(appendNonModifiableSuffixIfNeeded);
         }
         case "CheckResultBased":
-            return getCheckResultBasedRangeTranslation(locale, entity, responsiveTextSize, value.check_result_based);
+            return getCheckResultBasedRangeTranslation(value.CheckResultBased).then(appendNonModifiableSuffixIfNeeded);
         default:
             return assertExhaustive(value);
     }
@@ -54,28 +58,24 @@ const getRangeValueTranslation = (getSkillModificationLevelById, locale, speed,
 /**
  * Returns the text for the range of an activatable skill.
  */
-export const getTextForActivatableSkillRange = (getSkillModificationLevelById, locale, speed, responsiveTextSize, entity, value) => {
-    const rangeValue = getRangeValueTranslation(getSkillModificationLevelById, locale, speed, responsiveTextSize, entity, value.value);
-    const withReplacement = replaceTextIfRequested("replacement", value.translations, locale.translateMap, responsiveTextSize, rangeValue);
-    return appendNoteIfRequested("note", value.translations, locale.translateMap, responsiveTextSize, withReplacement);
-};
-const getTextForTinyAcitvatableRange = (locale, responsiveTextSize, entity, value) => {
-    switch (value.tag) {
+export const renderRangeValue = (value, shouldAppendNonModifiableSuffix) => {
+    switch (value.kind) {
+        case "Modifiable":
+            return renderModifiableRange(value.Modifiable);
+        case "Sight":
         case "Self":
-            return getSelfTranslation(locale);
+        case "Global":
         case "Touch":
-            return getTouchTranslation(locale, entity, responsiveTextSize);
         case "Fixed":
-            return getFixedRangeTranslation(locale, entity, responsiveTextSize, value.fixed);
+        case "CheckResultBased":
+            return renderNonModifiableRange(value, shouldAppendNonModifiableSuffix);
         default:
             return assertExhaustive(value);
     }
 };
 /**
- * Returns the text for the range of a cantrip.
- */
-export const getTextForCantripRange = (locale, responsiveTextSize, value) => getTextForTinyAcitvatableRange(locale, responsiveTextSize, Entity.Cantrip, value);
-/**
- * Returns the text for the range of a blessing.
+ * Returns the text for the range of an activatable skill.
  */
-export const getTextForBlessingRange = (locale, responsiveTextSize, value) => getTextForTinyAcitvatableRange(locale, responsiveTextSize, Entity.Blessing, value);
+export const renderRange = (value) => renderRangeValue(value.value, true)
+    .then(text => replaceTextIfNeeded(value.translations, text))
+    .then(text => appendNoteIfNeeded(value.translations, text));

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

@@ -1,4 +1,4 @@
-import { FastSkillModificationLevelConfig, SkillModificationLevel, SlowSkillModificationLevelConfig } from "optolith-database-schema/types/SkillModificationLevel";
+import { FastSkillModificationLevelConfig, SkillModificationLevel, SlowSkillModificationLevelConfig } from "optolith-database-schema/gen";
 /**
  * The speed of an activatable skill.
  */
@@ -6,7 +6,16 @@ export declare enum Speed {
     Fast = 0,
     Slow = 1
 }
+type SpeedMap = {
+    [Speed.Fast]: FastSkillModificationLevelConfig;
+    [Speed.Slow]: SlowSkillModificationLevelConfig;
+};
 /**
  * Returns a common value for a skill modification level depending on the speed.
  */
-export declare const getModifiableBySpeed: <T>(fast: (config: FastSkillModificationLevelConfig) => T, slow: (config: SlowSkillModificationLevelConfig) => T, speed: Speed, level: SkillModificationLevel) => T;
+export declare const getModifiableBySpeed: <S extends Speed, K extends keyof SpeedMap[S]>(speed: S, key: K, level: SkillModificationLevel) => SpeedMap[S][K];
+/**
+ * Returns a common value for a skill modification level depending on the speed.
+ */
+export declare const getMapModifiableBySpeed: <T>(fast: (config: FastSkillModificationLevelConfig) => T, slow: (config: SlowSkillModificationLevelConfig) => T, speed: Speed, level: SkillModificationLevel) => T;
+export {};

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

@@ -10,7 +10,20 @@ export var Speed;
 /**
  * Returns a common value for a skill modification level depending on the speed.
  */
-export const getModifiableBySpeed = (fast, slow, speed, level) => {
+export const getModifiableBySpeed = (speed, key, level) => {
+    switch (speed) {
+        case Speed.Fast:
+            return level.fast[key];
+        case Speed.Slow:
+            return level.slow[key];
+        default:
+            return assertExhaustive(speed);
+    }
+};
+/**
+ * Returns a common value for a skill modification level depending on the speed.
+ */
+export const getMapModifiableBySpeed = (fast, slow, speed, level) => {
     switch (speed) {
         case Speed.Fast:
             return fast(level.fast);