@optolith/entity-descriptions 0.0.1

package/lib/entities/liturgicalChant.js

@@ -0,0 +1,244 @@
+import { isNotNullish } from "@optolith/helpers/nullable";
+import { assertExhaustive } from "@optolith/helpers/typeSafety";
+import { createLibraryEntryCreator, } from "../libraryEntry.js";
+import { getTextForBlessingDuration } from "./partial/rated/activatable/duration.js";
+import { getTextForEffect } from "./partial/rated/activatable/effect.js";
+import { Entity } from "./partial/rated/activatable/entity.js";
+import { getTextForFastOneTimePerformanceParameters, getTextForFastSustainedPerformanceParameters, getTextForSlowOneTimePerformanceParameters, getTextForSlowSustainedPerformanceParameters, } from "./partial/rated/activatable/index.js";
+import { getTextForBlessingRange } from "./partial/rated/activatable/range.js";
+import { getTextForTargetCategory } from "./partial/rated/activatable/targetCategory.js";
+import { createImprovementCost } from "./partial/rated/improvementCost.js";
+import { getTextForCheck } from "./partial/rated/skillCheck.js";
+import { ResponsiveTextSize } from "./partial/responsiveText.js";
+const getTextForTraditions = (deps, values) => {
+    const getAspectName = (ref) => deps.translateMap(deps.getAspectById(ref.id.aspect)?.translations)?.name;
+    const text = values
+        .map((trad) => {
+        switch (trad.tag) {
+            case "GeneralAspect":
+                return getAspectName(trad.general_aspect);
+            case "Tradition": {
+                const traditionTranslation = deps.translateMap(deps.getBlessedTraditionById(trad.tradition.tradition.id.blessed_tradition)?.translations);
+                const name = traditionTranslation?.name_compressed ?? traditionTranslation?.name;
+                if (name === undefined) {
+                    return undefined;
+                }
+                const aspects = trad.tradition.aspects
+                    ?.map(getAspectName)
+                    .filter(isNotNullish)
+                    .sort(deps.localeCompare) ?? [];
+                if (aspects.length === 0) {
+                    return name;
+                }
+                return `${name} (${aspects.join(" and ")})`;
+            }
+            default:
+                return assertExhaustive(trad);
+        }
+    })
+        .filter(isNotNullish)
+        .join(", ");
+    return {
+        label: deps.translate("Traditions"),
+        value: text,
+    };
+};
+/**
+ * Get a JSON representation of the rules text for a blessing.
+ */
+export const getBlessingLibraryEntry = createLibraryEntryCreator((entry, { getTargetCategoryById }) => ({ translate, translateMap }) => {
+    const translation = translateMap(entry.translations);
+    if (translation === undefined) {
+        return undefined;
+    }
+    const range = getTextForBlessingRange({ translate }, entry.parameters.range, {
+        responsiveText: ResponsiveTextSize.Full,
+    });
+    const duration = getTextForBlessingDuration({ translate, translateMap }, entry.parameters.duration, {
+        responsiveText: ResponsiveTextSize.Full,
+    });
+    return {
+        title: translation.name,
+        className: "blessing",
+        content: [
+            {
+                label: translate("Effect"),
+                value: translation.effect,
+            },
+            {
+                label: translate("Range"),
+                value: range !== translation.range
+                    ? `***${range}*** (${translation.range})`
+                    : range,
+            },
+            {
+                label: translate("Duration"),
+                value: duration !== translation.duration
+                    ? `***${duration}*** (${translation.duration})`
+                    : duration,
+            },
+            getTextForTargetCategory({ translate, translateMap, getTargetCategoryById }, entry.target),
+        ],
+        src: entry.src,
+    };
+});
+/**
+ * Get a JSON representation of the rules text for a liturgical chant.
+ */
+export const getLiturgicalChantLibraryEntry = createLibraryEntryCreator((entry, { getAttributeById, getSpirit, getToughness, getSkillModificationLevelById, getTargetCategoryById, getBlessedTraditionById, getAspectById, }) => ({ translate, translateMap, localeCompare }) => {
+    const translation = translateMap(entry.translations);
+    if (translation === undefined) {
+        return undefined;
+    }
+    const { castingTime, cost, range, duration } = (() => {
+        switch (entry.parameters.tag) {
+            case "OneTime":
+                return getTextForFastOneTimePerformanceParameters({
+                    getSkillModificationLevelById,
+                    translate,
+                    translateMap,
+                }, entry.parameters.one_time, {
+                    entity: Entity.LiturgicalChant,
+                    responsiveText: ResponsiveTextSize.Full,
+                });
+            case "Sustained":
+                return getTextForFastSustainedPerformanceParameters({
+                    getSkillModificationLevelById,
+                    translate,
+                    translateMap,
+                }, entry.parameters.sustained, {
+                    entity: Entity.LiturgicalChant,
+                    responsiveText: ResponsiveTextSize.Full,
+                });
+            default:
+                return assertExhaustive(entry.parameters);
+        }
+    })();
+    return {
+        title: translation.name,
+        className: "liturgical-chant",
+        content: [
+            getTextForCheck({ translate, translateMap, getAttributeById }, entry.check, {
+                value: entry.check_penalty,
+                responsiveText: ResponsiveTextSize.Full,
+                getSpirit,
+                getToughness,
+            }),
+            ...getTextForEffect(translation.effect, translate),
+            {
+                label: translate("Liturgical Time"),
+                value: castingTime !== translation.casting_time.full
+                    ? `***${castingTime}*** (${translation.casting_time.full})`
+                    : castingTime,
+            },
+            {
+                label: translate("KP Cost"),
+                value: cost !== translation.cost.full
+                    ? `***${cost}*** (${translation.cost.full})`
+                    : cost,
+            },
+            {
+                label: translate("Range"),
+                value: range !== translation.range.full
+                    ? `***${range}*** (${translation.range.full})`
+                    : range,
+            },
+            {
+                label: translate("Duration"),
+                value: duration !== translation.duration.full
+                    ? `***${duration}*** (${translation.duration.full})`
+                    : duration,
+            },
+            getTextForTargetCategory({ translate, translateMap, getTargetCategoryById }, entry.target),
+            getTextForTraditions({
+                translate,
+                translateMap,
+                localeCompare,
+                getBlessedTraditionById,
+                getAspectById,
+            }, entry.traditions),
+            createImprovementCost(translate, entry.improvement_cost),
+        ],
+        src: entry.src,
+    };
+});
+/**
+ * Get a JSON representation of the rules text for a ceremony.
+ */
+export const getCeremonyLibraryEntry = createLibraryEntryCreator((entry, { getAttributeById, getSpirit, getToughness, getSkillModificationLevelById, getTargetCategoryById, getBlessedTraditionById, getAspectById, }) => ({ translate, translateMap, localeCompare }) => {
+    const translation = translateMap(entry.translations);
+    if (translation === undefined) {
+        return undefined;
+    }
+    const { castingTime, cost, range, duration } = (() => {
+        switch (entry.parameters.tag) {
+            case "OneTime":
+                return getTextForSlowOneTimePerformanceParameters({
+                    getSkillModificationLevelById,
+                    translate,
+                    translateMap,
+                }, entry.parameters.one_time, {
+                    entity: Entity.Ceremony,
+                    responsiveText: ResponsiveTextSize.Full,
+                });
+            case "Sustained":
+                return getTextForSlowSustainedPerformanceParameters({
+                    getSkillModificationLevelById,
+                    translate,
+                    translateMap,
+                }, entry.parameters.sustained, {
+                    entity: Entity.Ceremony,
+                    responsiveText: ResponsiveTextSize.Full,
+                });
+            default:
+                return assertExhaustive(entry.parameters);
+        }
+    })();
+    return {
+        title: translation.name,
+        className: "ceremony",
+        content: [
+            getTextForCheck({ translate, translateMap, getAttributeById }, entry.check, {
+                value: entry.check_penalty,
+                responsiveText: ResponsiveTextSize.Full,
+                getSpirit,
+                getToughness,
+            }),
+            ...getTextForEffect(translation.effect, translate),
+            {
+                label: translate("Ceremonial Time"),
+                value: castingTime !== translation.casting_time.full
+                    ? `***${castingTime}*** (${translation.casting_time.full})`
+                    : castingTime,
+            },
+            {
+                label: translate("KP Cost"),
+                value: cost !== translation.cost.full
+                    ? `***${cost}*** (${translation.cost.full})`
+                    : cost,
+            },
+            {
+                label: translate("Range"),
+                value: range !== translation.range.full
+                    ? `***${range}*** (${translation.range.full})`
+                    : range,
+            },
+            {
+                label: translate("Duration"),
+                value: duration !== translation.duration.full
+                    ? `***${duration}*** (${translation.duration.full})`
+                    : duration,
+            },
+            getTextForTargetCategory({ translate, translateMap, getTargetCategoryById }, entry.target),
+            getTextForTraditions({
+                translate,
+                translateMap,
+                localeCompare,
+                getBlessedTraditionById,
+                getAspectById,
+            }, entry.traditions),
+            createImprovementCost(translate, entry.improvement_cost),
+        ],
+        src: entry.src,
+    };
+});

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

@@ -0,0 +1,25 @@
+import { FastCastingTime, SlowCastingTime } from "optolith-database-schema/types/_ActivatableSkillCastingTime";
+import { GetById } from "../../../../helpers/getTypes.js";
+import { Translate } from "../../../../helpers/translate.js";
+import { ResponsiveTextSize } from "../../responsiveText.js";
+import { Entity } from "./entity.js";
+/**
+ * Get the text for the casting time of a fast activatable skill.
+ */
+export declare const getTextForFastCastingTime: (deps: {
+    getSkillModificationLevelById: GetById.Static.SkillModificationLevel;
+    translate: Translate;
+}, value: FastCastingTime, env: {
+    entity: Entity;
+    responsiveText: ResponsiveTextSize;
+}) => string;
+/**
+ * Get the text for the casting time of a slow activatable skill.
+ */
+export declare const getTextForSlowCastingTime: (deps: {
+    getSkillModificationLevelById: GetById.Static.SkillModificationLevel;
+    translate: Translate;
+}, value: SlowCastingTime, env: {
+    entity: Entity;
+    responsiveText: ResponsiveTextSize;
+}) => string;

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

@@ -0,0 +1,50 @@
+import { isNotNullish, mapNullable } from "@optolith/helpers/nullable";
+import { assertExhaustive } from "@optolith/helpers/typeSafety";
+import { MISSING_VALUE } from "../../unknown.js";
+import { ModifiableParameter } from "./modifiableParameter.js";
+import { getTextForNonModifiableSuffix } from "./nonModifiable.js";
+import { Speed } from "./speed.js";
+import { formatTimeSpan } from "./units.js";
+const getTextForModifiableCastingTime = (deps, value, env) => mapNullable(deps.getSkillModificationLevelById(value.initial_modification_level), ({ fast: { casting_time: fastTime }, slow: { casting_time: slowTime }, }) => {
+    switch (env.speed) {
+        case Speed.Fast:
+            return formatTimeSpan(deps.translate, env.responsiveText, "Actions", fastTime);
+        case Speed.Slow:
+            return formatTimeSpan(deps.translate, env.responsiveText, slowTime.unit, slowTime.value);
+        default:
+            return assertExhaustive(env.speed);
+    }
+}) ?? MISSING_VALUE;
+const getTextForFastSkillNonModifiableCastingTime = (deps, value, env) => formatTimeSpan(deps.translate, env.responsiveText, "Actions", value.actions) +
+    getTextForNonModifiableSuffix(deps.translate, env.entity, ModifiableParameter.CastingTime, env.responsiveText);
+const getTextForSlowSkillNonModifiableCastingTime = (deps, value, env) => formatTimeSpan(deps.translate, env.responsiveText, value.unit, value.value) +
+    getTextForNonModifiableSuffix(deps.translate, env.entity, ModifiableParameter.CastingTime, env.responsiveText);
+const getTextForCastingTime = (deps, value, env, getTextForNonModifiableCastingTime) => {
+    switch (value.tag) {
+        case "Modifiable":
+            return getTextForModifiableCastingTime(deps, value.modifiable, env);
+        case "NonModifiable":
+            return getTextForNonModifiableCastingTime(value.non_modifiable);
+        default:
+            return assertExhaustive(value);
+    }
+};
+const getTextForCastingTimeDuringLovemaking = (deps, value, env) => formatTimeSpan(deps.translate, env.responsiveText, value.unit, value.value);
+/**
+ * Get the text for the casting time of a fast activatable skill.
+ */
+export const getTextForFastCastingTime = (deps, value, env) => [
+    mapNullable(value.default, (def) => getTextForCastingTime(deps, def, { ...env, speed: Speed.Fast }, (nonModifiableValue) => getTextForFastSkillNonModifiableCastingTime(deps, nonModifiableValue, env))),
+    mapNullable(value.during_lovemaking, (duringLovemaking) => getTextForCastingTimeDuringLovemaking(deps, duringLovemaking, env)),
+]
+    .filter(isNotNullish)
+    .join(" / ");
+/**
+ * Get the text for the casting time of a slow activatable skill.
+ */
+export const getTextForSlowCastingTime = (deps, value, env) => [
+    mapNullable(value.default, (def) => getTextForCastingTime(deps, def, { ...env, speed: Speed.Slow }, (nonModifiableValue) => getTextForSlowSkillNonModifiableCastingTime(deps, nonModifiableValue, env))),
+    mapNullable(value.during_lovemaking, (duringLovemaking) => getTextForCastingTimeDuringLovemaking(deps, duringLovemaking, env)),
+]
+    .filter(isNotNullish)
+    .join(" / ");

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

@@ -0,0 +1,7 @@
+import { CheckResultBased } from "optolith-database-schema/types/_ActivatableSkillCheckResultBased";
+import { Translate } from "../../../../helpers/translate.js";
+/**
+ * Returns the value text for a check-result-based parameter of an activatable
+ * skill.
+ */
+export declare const getTextForCheckResultBased: (value: CheckResultBased, translate: Translate) => string;

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

@@ -0,0 +1,28 @@
+import { mapNullableDefault } from "@optolith/helpers/nullable";
+import { assertExhaustive } from "@optolith/helpers/typeSafety";
+const getCheckResultBaseValue = (baseValue, translate) => {
+    switch (baseValue) {
+        case "QualityLevels":
+            return translate("QL");
+        case "SkillPoints":
+            return translate("SP");
+        default:
+            return assertExhaustive(baseValue);
+    }
+};
+const getArithmeticSymbol = (arithmetic) => {
+    switch (arithmetic) {
+        case "Divide":
+            return ` / `;
+        case "Multiply":
+            return ` × `;
+        default:
+            return assertExhaustive(arithmetic);
+    }
+};
+/**
+ * Returns the value text for a check-result-based parameter of an activatable
+ * skill.
+ */
+export const getTextForCheckResultBased = (value, translate) => getCheckResultBaseValue(value.base, translate) +
+    mapNullableDefault(value.modifier, (modifier) => getArithmeticSymbol(modifier.arithmetic) + modifier.value, "");

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

@@ -0,0 +1,30 @@
+import { OneTimeCost, SustainedCost } from "optolith-database-schema/types/_ActivatableSkillCost";
+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 cost of a one-time activatable skill.
+ */
+export declare const getTextForOneTimeCost: (deps: {
+    getSkillModificationLevelById: GetById.Static.SkillModificationLevel;
+    translate: Translate;
+    translateMap: TranslateMap;
+}, value: OneTimeCost, env: {
+    speed: Speed;
+    responsiveText: ResponsiveTextSize;
+    entity: Entity;
+}) => string;
+/**
+ * Returns the text for the cost of a sustained activatable skill.
+ */
+export declare const getTextForSustainedCost: (deps: {
+    getSkillModificationLevelById: GetById.Static.SkillModificationLevel;
+    translate: Translate;
+    translateMap: TranslateMap;
+}, value: SustainedCost, env: {
+    speed: Speed;
+    responsiveText: ResponsiveTextSize;
+    entity: Entity;
+}) => string;

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

@@ -0,0 +1,166 @@
+import { mapNullable, mapNullableDefault } from "@optolith/helpers/nullable";
+import { assertExhaustive } from "@optolith/helpers/typeSafety";
+import { getResponsiveText, getResponsiveTextOptional, replaceTextIfRequested, responsive, } from "../../responsiveText.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);
+}) ?? 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))) ?? "";
+    return countableText + minimumTotalText;
+}) ?? "";
+const getTextForPermanentValue = (value, responsiveText, translate) => value === 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);
+};
+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) => {
+    switch (value.tag) {
+        case "Modifiable":
+            return getTextForModifiableOneTimeCost(deps, value.modifiable, env);
+        case "NonModifiable":
+            return getTextForNonModifiableOneTimeCost(deps, value.non_modifiable, env);
+        case "Indefinite":
+            return getTextForIndefiniteOneTimeCost(deps, value.indefinite, env);
+        default:
+            return assertExhaustive(value);
+    }
+};
+const getTextForMultipleOneTimeCosts = (deps, value, type, env) => {
+    const modifiable = !value.every((part) => part.tag === "Modifiable")
+        ? getTextForNonModifiableSuffix(deps.translate, env.entity, ModifiableParameter.Cost, env.responsiveText)
+        : "";
+    return (value
+        .map((part) => getTextForSingleOneTimeCost(deps, part, env))
+        .join((() => {
+        switch (type) {
+            case "conjunction":
+                return responsive(env.responsiveText, () => deps.translate(" and "), () => deps.translate(" + "));
+            case "disjunction":
+                return responsive(env.responsiveText, () => deps.translate(" or "), () => deps.translate(" / "));
+            default:
+                return assertExhaustive(type);
+        }
+    })()) + modifiable);
+};
+const getTextForCostMap = (deps, value, env) => {
+    const translation = deps.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)
+        .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);
+    return (formatCostP(costs) +
+        deps.translate(" for ") +
+        mapNullableDefault(translation?.list_prepend, (listPrepend) => `${listPrepend} `, "") +
+        labels +
+        (translation?.list_append ?? "") +
+        (permanentCosts !== undefined
+            ? deps.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) => {
+    switch (value.tag) {
+        case "Single":
+            return getTextForSingleOneTimeCost(deps, value.single, env);
+        case "Conjunction":
+            return getTextForMultipleOneTimeCosts(deps, value.conjunction, "conjunction", env);
+        case "Disjunction":
+            return getTextForMultipleOneTimeCosts(deps, value.disjunction, "disjunction", env);
+        case "Map":
+            return getTextForCostMap(deps, value.map, env);
+        default:
+            return assertExhaustive(value);
+    }
+};
+/**
+ * Returns the text for the cost of a sustained activatable skill.
+ */
+export const getTextForSustainedCost = (deps, value, env) => {
+    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));
+        }
+        default:
+            return assertExhaustive(value);
+    }
+};

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

@@ -0,0 +1,40 @@
+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 { 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;
+/**
+ * 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;
+/**
+ * Returns the text for the duration of a cantrip.
+ */
+export declare const getTextForCantripDuration: (deps: {
+    translate: Translate;
+    translateMap: TranslateMap;
+}, value: CantripDuration, env: {
+    responsiveText: ResponsiveTextSize;
+}) => 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;