@optolith/entity-descriptions 0.0.1

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

@@ -0,0 +1,100 @@
+import { mapNullableDefault } 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);
+};
+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 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));
+};
+/**
+ * Returns the text for the duration of a one-time activatable skill.
+ */
+export const getTextForDurationForOneTime = (deps, value, env) => {
+    switch (value.tag) {
+        case "Immediate":
+            return getTextForImmediateDuration(deps, value.immediate, env);
+        case "Permanent":
+            return getTextForPermanentDuration(deps, value.permanent, env);
+        case "Fixed":
+            return getTextForFixedDuration(deps, value.fixed, env);
+        case "CheckResultBased":
+            return getTextForCheckResultBasedDuration(deps, value.check_result_based, env);
+        case "Indefinite":
+            return getResponsiveText(deps.translateMap(value.indefinite.translations)?.description, env.responsiveText);
+        default:
+            return assertExhaustive(value);
+    }
+};
+/**
+ * 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);
+/**
+ * Returns the text for the duration of a cantrip.
+ */
+export const getTextForCantripDuration = (deps, value, env) => {
+    switch (value.tag) {
+        case "Immediate":
+            return getTextForImmediateDuration(deps, value.immediate, env);
+        case "Fixed":
+            return getTextForFixedDuration(deps, value.fixed, env);
+        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);
+        }
+        default:
+            return assertExhaustive(value);
+    }
+};
+/**
+ * Returns the text for the duration of a blessing.
+ */
+export const getTextForBlessingDuration = (deps, value, env) => {
+    switch (value.tag) {
+        case "Immediate":
+            return getTextForImmediateDuration(deps, value.immediate, env);
+        case "Fixed":
+            return getTextForFixedDuration(deps, value.fixed, env);
+        case "Indefinite":
+            return getResponsiveText(deps.translateMap(value.indefinite.translations)?.description, env.responsiveText);
+        default:
+            return assertExhaustive(value);
+    }
+};

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

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

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

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

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

@@ -0,0 +1,11 @@
+/**
+ * The entity type of an activatable skill.
+ */
+export declare enum Entity {
+    Cantrip = 0,
+    Spell = 1,
+    Ritual = 2,
+    Blessing = 3,
+    LiturgicalChant = 4,
+    Ceremony = 5
+}

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

@@ -0,0 +1,12 @@
+/**
+ * The entity type of an activatable skill.
+ */
+export var Entity;
+(function (Entity) {
+    Entity[Entity["Cantrip"] = 0] = "Cantrip";
+    Entity[Entity["Spell"] = 1] = "Spell";
+    Entity[Entity["Ritual"] = 2] = "Ritual";
+    Entity[Entity["Blessing"] = 3] = "Blessing";
+    Entity[Entity["LiturgicalChant"] = 4] = "LiturgicalChant";
+    Entity[Entity["Ceremony"] = 5] = "Ceremony";
+})(Entity || (Entity = {}));

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

@@ -0,0 +1,69 @@
+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 { 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;
+}) => {
+    castingTime: string;
+    cost: string;
+    range: string;
+    duration: string;
+};
+/**
+ * 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;
+}) => {
+    castingTime: string;
+    cost: string;
+    range: string;
+    duration: string;
+};
+/**
+ * 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;
+}) => {
+    castingTime: string;
+    cost: string;
+    range: string;
+    duration: string;
+};
+/**
+ * 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;
+}) => {
+    castingTime: string;
+    cost: string;
+    range: string;
+    duration: string;
+};

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

@@ -0,0 +1,59 @@
+import { getTextForFastCastingTime, getTextForSlowCastingTime, } from "./castingTime.js";
+import { getTextForOneTimeCost, getTextForSustainedCost } from "./cost.js";
+import { getTextForDurationForOneTime, getTextForDurationForSustained, } from "./duration.js";
+import { getTextForActivatableSkillRange } from "./range.js";
+import { Speed } from "./speed.js";
+/**
+ * Get the texts for all fast one-time performance parameters.
+ */
+export const getTextForFastOneTimePerformanceParameters = (deps, value, env) => ({
+    castingTime: getTextForFastCastingTime(deps, value.casting_time, env),
+    cost: getTextForOneTimeCost(deps, value.cost, { speed: Speed.Fast, ...env }),
+    range: getTextForActivatableSkillRange(deps, value.range, {
+        speed: Speed.Fast,
+        ...env,
+    }),
+    duration: getTextForDurationForOneTime(deps, value.duration, env),
+});
+/**
+ * Get the texts for all fast sustained performance parameters.
+ */
+export const getTextForFastSustainedPerformanceParameters = (deps, value, env) => ({
+    castingTime: getTextForFastCastingTime(deps, value.casting_time, env),
+    cost: getTextForSustainedCost(deps, value.cost, {
+        speed: Speed.Fast,
+        ...env,
+    }),
+    range: getTextForActivatableSkillRange(deps, value.range, {
+        speed: Speed.Fast,
+        ...env,
+    }),
+    duration: getTextForDurationForSustained(deps, value.duration, env),
+});
+/**
+ * Get the texts for all slow one-time performance parameters.
+ */
+export const getTextForSlowOneTimePerformanceParameters = (deps, value, env) => ({
+    castingTime: getTextForSlowCastingTime(deps, value.casting_time, env),
+    cost: getTextForOneTimeCost(deps, value.cost, { speed: Speed.Slow, ...env }),
+    range: getTextForActivatableSkillRange(deps, value.range, {
+        speed: Speed.Slow,
+        ...env,
+    }),
+    duration: getTextForDurationForOneTime(deps, value.duration, env),
+});
+/**
+ * Get the texts for all slow sustained performance parameters.
+ */
+export const getTextForSlowSustainedPerformanceParameters = (deps, value, env) => ({
+    castingTime: getTextForSlowCastingTime(deps, value.casting_time, env),
+    cost: getTextForSustainedCost(deps, value.cost, {
+        speed: Speed.Slow,
+        ...env,
+    }),
+    range: getTextForActivatableSkillRange(deps, value.range, {
+        speed: Speed.Slow,
+        ...env,
+    }),
+    duration: getTextForDurationForSustained(deps, value.duration, env),
+});

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

@@ -0,0 +1,6 @@
+import { Translate } from "../../../../helpers/translate.js";
+import { ResponsiveTextSize } from "../../responsiveText.js";
+/**
+ * Returns the text to prepend for the `is_maximum` property.
+ */
+export declare const getTextForIsMaximum: (is_maximum: boolean | undefined, translate: Translate, responsiveText: ResponsiveTextSize) => string;

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

@@ -0,0 +1,10 @@
+import { responsive } from "../../responsiveText.js";
+/**
+ * Returns the text to prepend for the `is_maximum` property.
+ */
+export const getTextForIsMaximum = (is_maximum, translate, responsiveText) => {
+    if (is_maximum !== true) {
+        return "";
+    }
+    return responsive(responsiveText, () => translate("no more than "), () => translate("max. "));
+};

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

@@ -0,0 +1,8 @@
+/**
+ * A parameter that is designed to be modifiable.
+ */
+export declare enum ModifiableParameter {
+    CastingTime = 0,
+    Cost = 1,
+    Range = 2
+}

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

@@ -0,0 +1,9 @@
+/**
+ * A parameter that is designed to be modifiable.
+ */
+export var ModifiableParameter;
+(function (ModifiableParameter) {
+    ModifiableParameter[ModifiableParameter["CastingTime"] = 0] = "CastingTime";
+    ModifiableParameter[ModifiableParameter["Cost"] = 1] = "Cost";
+    ModifiableParameter[ModifiableParameter["Range"] = 2] = "Range";
+})(ModifiableParameter || (ModifiableParameter = {}));

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

@@ -0,0 +1,9 @@
+import { Translate } from "../../../../helpers/translate.js";
+import { ResponsiveTextSize } from "../../responsiveText.js";
+import { Entity } from "./entity.js";
+import { ModifiableParameter } from "./modifiableParameter.js";
+/**
+ * Returns the suffix for the text of a non-modifiable parameter that indicates
+ * that the parameter cannot be modified.
+ */
+export declare const getTextForNonModifiableSuffix: (translate: Translate, entity: Entity, param: ModifiableParameter, responsiveText: ResponsiveTextSize) => string;

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

@@ -0,0 +1,75 @@
+import { assertExhaustive } from "@optolith/helpers/typeSafety";
+import { ResponsiveTextSize } from "../../responsiveText.js";
+import { Entity } from "./entity.js";
+import { ModifiableParameter } from "./modifiableParameter.js";
+/**
+ * Returns the suffix for the text of a non-modifiable parameter that indicates
+ * that the parameter cannot be modified.
+ */
+export const getTextForNonModifiableSuffix = (translate, entity, param, responsiveText) => {
+    if (responsiveText === ResponsiveTextSize.Compressed) {
+        switch (entity) {
+            case Entity.Spell:
+            case Entity.Ritual:
+            case Entity.LiturgicalChant:
+            case Entity.Ceremony:
+                return translate(" (cannot modify)");
+            case Entity.Cantrip:
+            case Entity.Blessing:
+                return "";
+            default:
+                return assertExhaustive(entity);
+        }
+    }
+    switch (entity) {
+        case Entity.Spell:
+            switch (param) {
+                case ModifiableParameter.CastingTime:
+                    return translate(" (you cannot use a modification on this spell’s casting time)");
+                case ModifiableParameter.Cost:
+                    return translate(" (you cannot use a modification on this spell’s cost)");
+                case ModifiableParameter.Range:
+                    return translate(" (you cannot use a modification on this spell’s range)");
+                default:
+                    return assertExhaustive(param);
+            }
+        case Entity.Ritual:
+            switch (param) {
+                case ModifiableParameter.CastingTime:
+                    return translate(" (you cannot use a modification on this ritual’s ritual time)");
+                case ModifiableParameter.Cost:
+                    return translate(" (you cannot use a modification on this ritual’s cost)");
+                case ModifiableParameter.Range:
+                    return translate(" (you cannot use a modification on this ritual’s range)");
+                default:
+                    return assertExhaustive(param);
+            }
+        case Entity.LiturgicalChant:
+            switch (param) {
+                case ModifiableParameter.CastingTime:
+                    return translate(" (you cannot use a modification on this chant’s liturgical time)");
+                case ModifiableParameter.Cost:
+                    return translate(" (you cannot use a modification on this chant’s cost)");
+                case ModifiableParameter.Range:
+                    return translate(" (you cannot use a modification on this chant’s range)");
+                default:
+                    return assertExhaustive(param);
+            }
+        case Entity.Ceremony:
+            switch (param) {
+                case ModifiableParameter.CastingTime:
+                    return translate(" (you cannot use a modification on this ceremony’s ceremonial time)");
+                case ModifiableParameter.Cost:
+                    return translate(" (you cannot use a modification on this ceremony’s cost)");
+                case ModifiableParameter.Range:
+                    return translate(" (you cannot use a modification on this ceremony’s range)");
+                default:
+                    return assertExhaustive(param);
+            }
+        case Entity.Cantrip:
+        case Entity.Blessing:
+            return "";
+        default:
+            return assertExhaustive(entity);
+    }
+};

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

@@ -0,0 +1,10 @@
+/**
+ * Wraps a string in parentheses with a leading space if it is not empty or
+ * `undefined`.
+ */
+export declare const parensIf: (text: string | undefined) => string;
+/**
+ * Appends a string in parentheses with a leading space if it is not empty or
+ * `undefined`.
+ */
+export declare const appendInParens: (text: string, append: string | undefined) => string;

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

@@ -0,0 +1,10 @@
+/**
+ * Wraps a string in parentheses with a leading space if it is not empty or
+ * `undefined`.
+ */
+export const parensIf = (text) => text === undefined || text === "" ? "" : ` (${text})`;
+/**
+ * Appends a string in parentheses with a leading space if it is not empty or
+ * `undefined`.
+ */
+export const appendInParens = (text, append) => append === undefined || append === "" ? text : `${text} (${append})`;

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

@@ -0,0 +1,36 @@
+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 { Translate, TranslateMap } from "../../../../helpers/translate.js";
+import { ResponsiveTextSize } from "../../responsiveText.js";
+import { Entity } from "./entity.js";
+import { Speed } from "./speed.js";
+/**
+ * Returns the text for the range of an activatable skill.
+ */
+export declare const getTextForActivatableSkillRange: (deps: {
+    getSkillModificationLevelById: GetById.Static.SkillModificationLevel;
+    translate: Translate;
+    translateMap: TranslateMap;
+}, value: Range, env: {
+    speed: Speed;
+    responsiveText: ResponsiveTextSize;
+    entity: Entity;
+}) => string;
+/**
+ * Returns the text for the range of a cantrip.
+ */
+export declare const getTextForCantripRange: (deps: {
+    translate: Translate;
+}, value: CantripRange, env: {
+    responsiveText: ResponsiveTextSize;
+}) => string;
+/**
+ * Returns the text for the range of a blessing.
+ */
+export declare const getTextForBlessingRange: (deps: {
+    translate: Translate;
+}, value: BlessingRange, env: {
+    responsiveText: ResponsiveTextSize;
+}) => string;

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

@@ -0,0 +1,122 @@
+import { assertExhaustive } from "@optolith/helpers/typeSafety";
+import { getResponsiveText, getResponsiveTextOptional, responsive, } from "../../responsiveText.js";
+import { MISSING_VALUE } from "../../unknown.js";
+import { getTextForCheckResultBased } from "./checkResultBased.js";
+import { getTextForIsMaximum } from "./isMaximum.js";
+import { ModifiableParameter } from "./modifiableParameter.js";
+import { getTextForNonModifiableSuffix } from "./nonModifiable.js";
+import { Speed } from "./speed.js";
+const toRangeUnit = (unit, value, translate, responsiveText) => {
+    switch (unit) {
+        case "Steps":
+            return responsive(responsiveText, () => translate("{0} yards", value), () => translate("{0} yd", value));
+        case "Miles":
+            return responsive(responsiveText, () => translate("{0} miles", value), () => translate("{0} mi.", value));
+        default:
+            return assertExhaustive(unit);
+    }
+};
+/**
+ * Returns the text for the range of an activatable skill.
+ */
+export const getTextForActivatableSkillRange = (deps, value, env) => {
+    const translation = deps.translateMap(value.translations);
+    if (value.translations !== undefined && translation === undefined) {
+        return MISSING_VALUE;
+    }
+    const rangeValue = (() => {
+        switch (value.value.tag) {
+            case "Modifiable": {
+                const modificationLevel = deps.getSkillModificationLevelById(value.value.modifiable.initial_modification_level);
+                if (modificationLevel === undefined) {
+                    return MISSING_VALUE;
+                }
+                const range = (() => {
+                    switch (env.speed) {
+                        case Speed.Fast:
+                            return modificationLevel.fast.range;
+                        case Speed.Slow:
+                            return modificationLevel.slow.range;
+                        default:
+                            return assertExhaustive(env.speed);
+                    }
+                })();
+                if (range === 1) {
+                    return deps.translate("Touch");
+                }
+                return toRangeUnit("Steps", range, deps.translate, env.responsiveText);
+            }
+            case "Sight":
+                return deps.translate("Sight");
+            case "Self":
+                return deps.translate("Self");
+            case "Global":
+                return deps.translate("Global");
+            case "Touch":
+                return (deps.translate("Touch") +
+                    getTextForNonModifiableSuffix(deps.translate, env.entity, ModifiableParameter.Range, env.responsiveText));
+            case "Fixed": {
+                return (toRangeUnit(value.value.fixed.unit, value.value.fixed.value, deps.translate, env.responsiveText) +
+                    getTextForNonModifiableSuffix(deps.translate, env.entity, ModifiableParameter.Range, env.responsiveText));
+            }
+            case "CheckResultBased": {
+                const isMaximum = getTextForIsMaximum(value.value.check_result_based.is_maximum, deps.translate, env.responsiveText);
+                const isRadius = value.value.check_result_based.is_radius === true
+                    ? ` ${deps.translate("Radius")}`
+                    : "";
+                return (isMaximum +
+                    toRangeUnit(value.value.check_result_based.unit, getTextForCheckResultBased(value.value.check_result_based, deps.translate), deps.translate, env.responsiveText) +
+                    isRadius +
+                    getTextForNonModifiableSuffix(deps.translate, env.entity, ModifiableParameter.Range, env.responsiveText));
+            }
+            default:
+                return assertExhaustive(value.value);
+        }
+    })();
+    const withReplacement = translation?.replacement !== undefined
+        ? getResponsiveText(translation.replacement, env.responsiveText).replace("$1", rangeValue)
+        : rangeValue;
+    const withNote = (() => {
+        if (translation?.note === undefined) {
+            return withReplacement;
+        }
+        const note = getResponsiveTextOptional(translation.note, env.responsiveText);
+        if (note === undefined) {
+            return withReplacement;
+        }
+        return `${withReplacement} (${note})`;
+    })();
+    return withNote;
+};
+/**
+ * Returns the text for the range of a cantrip.
+ */
+export const getTextForCantripRange = (deps, value, env) => {
+    switch (value.tag) {
+        case "Self":
+            return deps.translate("Self");
+        case "Touch":
+            return deps.translate("Touch");
+        case "Fixed": {
+            return toRangeUnit(value.fixed.unit, value.fixed.value, deps.translate, env.responsiveText);
+        }
+        default:
+            return assertExhaustive(value);
+    }
+};
+/**
+ * Returns the text for the range of a blessing.
+ */
+export const getTextForBlessingRange = (deps, value, env) => {
+    switch (value.tag) {
+        case "Self":
+            return deps.translate("Self");
+        case "Touch":
+            return deps.translate("Touch");
+        case "Fixed": {
+            return toRangeUnit(value.fixed.unit, value.fixed.value, deps.translate, env.responsiveText);
+        }
+        default:
+            return assertExhaustive(value);
+    }
+};

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

@@ -0,0 +1,12 @@
+import { FastSkillModificationLevelConfig, SkillModificationLevel, SlowSkillModificationLevelConfig } from "optolith-database-schema/types/SkillModificationLevel";
+/**
+ * The speed of an activatable skill.
+ */
+export declare enum Speed {
+    Fast = 0,
+    Slow = 1
+}
+/**
+ * Returns a common value for a skill modification level depending on the speed.
+ */
+export declare const getModifiableBySpeed: <T>(level: SkillModificationLevel, speed: Speed, fast: (config: FastSkillModificationLevelConfig) => T, slow: (config: SlowSkillModificationLevelConfig) => T) => T;

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

@@ -0,0 +1,22 @@
+import { assertExhaustive } from "@optolith/helpers/typeSafety";
+/**
+ * The speed of an activatable skill.
+ */
+export var Speed;
+(function (Speed) {
+    Speed[Speed["Fast"] = 0] = "Fast";
+    Speed[Speed["Slow"] = 1] = "Slow";
+})(Speed || (Speed = {}));
+/**
+ * Returns a common value for a skill modification level depending on the speed.
+ */
+export const getModifiableBySpeed = (level, speed, fast, slow) => {
+    switch (speed) {
+        case Speed.Fast:
+            return fast(level.fast);
+        case Speed.Slow:
+            return slow(level.slow);
+        default:
+            return assertExhaustive(speed);
+    }
+};

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

@@ -0,0 +1,12 @@
+import { TargetCategory } from "optolith-database-schema/types/_ActivatableSkillTargetCategory";
+import { GetById } from "../../../../helpers/getTypes.js";
+import { Translate, TranslateMap } from "../../../../helpers/translate.js";
+import { LibraryEntryContent } from "../../../../libraryEntry.js";
+/**
+ * Get the text for the target category.
+ */
+export declare const getTextForTargetCategory: (deps: {
+    translate: Translate;
+    translateMap: TranslateMap;
+    getTargetCategoryById: GetById.Static.TargetCategory;
+}, values: TargetCategory) => LibraryEntryContent;