@optolith/entity-descriptions 0.4.26 → 0.6.0

package/lib/entities/partial/prerequisites/prerequisiteGroups.js

@@ -82,7 +82,10 @@ export const printGeneralPrerequisiteGroup = (getInstanceById, getResolvedSelect
         case "RatedSum":
             return printRatedSumPrerequisite(getInstanceById, locale, prerequisite.RatedSum);
         case "Enhancement":
-            return printEnhancementPrerequisite(getInstanceById, locale, prerequisite.Enhancement);
+            return printEnhancementPrerequisite(prerequisite.Enhancement).run({
+                ...locale,
+                getInstanceById,
+            });
         case "Text":
             return printTextPrerequisite(locale, prerequisite.Text);
         case "SexualCharacteristic":
@@ -262,7 +265,11 @@ export const printEnhancementPrerequisiteGroup = (getInstanceById, locale, prere
         case "Rated":
             return printRatedPrerequisite(getInstanceById, locale, prerequisite.Rated);
         case "Enhancement":
-            return printEnhancementPrerequisite(getInstanceById, locale, prerequisite.Enhancement);
+            return printEnhancementPrerequisite(prerequisite.Enhancement).run({
+                ...locale,
+                getInstanceById,
+                hideParent: true,
+            });
         default:
             return assertExhaustive(prerequisite);
     }

package/lib/entities/partial/prerequisites/single/enhancement.d.ts

@@ -1,8 +1,12 @@
+import { Reader } from "@elyukai/utils/reader";
 import type { EnhancementPrerequisite } from "@optolith/database-schema/gen";
-import type { GetInstanceById } from "../../../../helpers/getTypes.js";
-import type { LocaleEnvironment } from "../../../../helpers/locale.js";
+import { type StdEnv } from "../../reader.js";
 import type { PrerequisitePart } from "../part.js";
+type EnvExtra = {
+    hideParent?: true;
+};
 /**
  * Get the translation of an external enhancement prerequisite.
  */
-export declare const printEnhancementPrerequisite: (getInstanceById: GetInstanceById<"Spell" | "Ritual" | "LiturgicalChant" | "Ceremony" | "Enhancement">, locale: Pick<LocaleEnvironment, "translate" | "translateMap">, prerequisite: EnhancementPrerequisite) => PrerequisitePart | undefined;
+export declare const printEnhancementPrerequisite: (prerequisite: EnhancementPrerequisite) => Reader<StdEnv<"t" | "tm" | "ibi", "Enhancement" | "Spell" | "Ritual" | "LiturgicalChant" | "Ceremony"> & EnvExtra, PrerequisitePart | undefined>;
+export {};

package/lib/entities/partial/prerequisites/single/enhancement.js

@@ -1,41 +1,35 @@
+import { Reader } from "@elyukai/utils/reader";
 import { assertExhaustive } from "@optolith/helpers/typeSafety";
+import { fromUniformCase } from "tsondb/schema/gen";
+import { attributedNameFromInstanceR, getInstanceByIdR, translateR, } from "../../reader.js";
 import { MISSING_VALUE } from "../../unknown.js";
-const printLabel = (locale, skillId) => {
+const printLabel = (skillId) => {
     switch (skillId.kind) {
         case "Spell":
         case "Ritual":
-            return locale.translate("spell enhancement");
+            return translateR("spell enhancement");
         case "LiturgicalChant":
         case "Ceremony":
-            return locale.translate("liturgical enhancement");
+            return translateR("liturgical enhancement");
         default:
             return assertExhaustive(skillId);
     }
 };
-const getSkill = (getInstanceById, parentId) => {
-    switch (parentId.kind) {
-        case "Spell":
-            return getInstanceById("Spell", parentId.Spell);
-        case "Ritual":
-            return getInstanceById("Ritual", parentId.Ritual);
-        case "LiturgicalChant":
-            return getInstanceById("LiturgicalChant", parentId.LiturgicalChant);
-        case "Ceremony":
-            return getInstanceById("Ceremony", parentId.Ceremony);
-        default:
-            return assertExhaustive(parentId);
-    }
-};
 /**
  * Get the translation of an external enhancement prerequisite.
  */
-export const printEnhancementPrerequisite = (getInstanceById, locale, prerequisite) => {
-    const enhancement = getInstanceById("Enhancement", prerequisite.id);
-    const skill = enhancement && getSkill(getInstanceById, enhancement.parent);
-    return {
-        label: `${enhancement ? printLabel(locale, enhancement.parent) : MISSING_VALUE} `,
-        value: `*${locale.translateMap(enhancement?.translations)?.name ?? MISSING_VALUE}* ${locale.translate("for")} ${locale.translateMap(skill?.translations)?.name ?? MISSING_VALUE}`,
+export const printEnhancementPrerequisite = (prerequisite) => getInstanceByIdR("Enhancement", prerequisite.id).thenW(enhancement => enhancement === undefined
+    ? Reader.of(undefined)
+    : getInstanceByIdR(enhancement.parent).thenW(skill => printLabel(enhancement.parent).thenW(label => Reader.asks((env) => env.hideParent ?? false).thenW(hideParent => attributedNameFromInstanceR(enhancement, "prerequisite", "Enhancement", prerequisite.id)
+        .map(name => name ?? MISSING_VALUE)
+        .thenW(name => hideParent
+        ? Reader.of(name)
+        : attributedNameFromInstanceR(skill, "prerequisite", enhancement.parent.kind, fromUniformCase(enhancement.parent))
+            .map(skillName => skillName ?? MISSING_VALUE)
+            .thenW(skillName => translateR("for").map(forText => `${name} ${forText} ${skillName}`)))
+        .map((value) => ({
+        label: `${label} `,
+        value,
         sentenceType: undefined,
         isMeta: false,
-    };
-};
+    }))))));

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

@@ -3,20 +3,20 @@ import { type StdReader } from "../../reader.js";
 /**
  * Renders the text for a non-modifiable casting time of a fast activatable skill.
  */
-export declare const renderFastSkillNonModifiableCastingTime: (value: FastSkillNonModifiableCastingTime) => StdReader<string, "t" | "rts">;
+export declare const renderFastSkillNonModifiableCastingTime: (value: FastSkillNonModifiableCastingTime) => StdReader<string, "t" | "tm" | "f" | "rts">;
 /**
  * Get the text for a non-modifiable casting time of a slow activatable skill.
  */
-export declare const renderSlowSkillNonModifiableCastingTime: (value: SlowSkillNonModifiableCastingTime) => StdReader<string, "t" | "rts">;
+export declare const renderSlowSkillNonModifiableCastingTime: (value: SlowSkillNonModifiableCastingTime) => StdReader<string, "t" | "tm" | "f" | "rts">;
 /**
  * Translate casting time.
  */
-export declare const renderCastingTime: <NonModifiable extends object>(renderNonModifiableCastingTime: (value: NonModifiable) => StdReader<string, "t" | "rts" | "s" | "nms">, value: CastingTime<NonModifiable>) => StdReader<string, "t" | "rts" | "s" | "nms" | "ibi", "SkillModificationLevel">;
+export declare const renderCastingTime: <NonModifiable extends object>(renderNonModifiableCastingTime: (value: NonModifiable) => StdReader<string, "t" | "tm" | "f" | "rts" | "s" | "nms">, value: CastingTime<NonModifiable>) => StdReader<string, "t" | "tm" | "f" | "rts" | "s" | "nms" | "ibi", "SkillModificationLevel">;
 /**
  * Get the text for the casting time of a fast activatable skill.
  */
-export declare const renderFastCastingTime: (value: FastCastingTime) => StdReader<string, "t" | "rts" | "nms" | "ibi", "SkillModificationLevel">;
+export declare const renderFastCastingTime: (value: FastCastingTime) => StdReader<string, "t" | "tm" | "f" | "rts" | "nms" | "ibi", "SkillModificationLevel">;
 /**
  * Get the text for the casting time of a slow activatable skill.
  */
-export declare const renderSlowCastingTime: (value: SlowCastingTime) => StdReader<string, "t" | "rts" | "nms" | "ibi", "SkillModificationLevel">;
+export declare const renderSlowCastingTime: (value: SlowCastingTime) => StdReader<string, "t" | "tm" | "f" | "rts" | "nms" | "ibi", "SkillModificationLevel">;

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

@@ -3,6 +3,7 @@ import { isNotNullish, mapNullable } from "@optolith/helpers/nullable";
 import { assertExhaustive } from "@optolith/helpers/typeSafety";
 import { Case } from "../../../../helpers/enums.js";
 import { getInstanceByIdFnR, modifiableBySpeedR } from "../../reader.js";
+import { appendNoteIfNeeded } from "../../responsiveText.js";
 import { formatCombinedTimeSpanR, formatTimeSpanR } from "../../units/timeSpan.js";
 import { MISSING_VALUE } from "../../unknown.js";
 import { appendNonModifiableSuffix, ModifiableParameter } from "./nonModifiableSuffix.js";
@@ -10,16 +11,18 @@ import { Speed } from "./speed.js";
 const deriveModifiableCastingTime = (modificationLevelId) => getInstanceByIdFnR().thenW(getInstanceById => mapNullable(getInstanceById("SkillModificationLevel", modificationLevelId), modificationLevel => modifiableBySpeedR("casting_time", modificationLevel).map(castingTime => typeof castingTime === "number"
     ? { value: castingTime, unit: Case("Actions") }
     : castingTime)) ?? Reader.of(undefined));
-const renderModifiableCastingTime = (value) => deriveModifiableCastingTime(value.initial_modification_level).thenW(castingTime => castingTime === undefined ? Reader.of(MISSING_VALUE) : formatCombinedTimeSpanR(castingTime));
+const renderModifiableCastingTime = (value) => deriveModifiableCastingTime(value.initial_modification_level)
+    .thenW(castingTime => castingTime === undefined ? Reader.of(MISSING_VALUE) : formatCombinedTimeSpanR(castingTime))
+    .thenW(text => appendNoteIfNeeded(value.translations, text));
 const renderCastingTimeDuringLovemaking = (value) => formatCombinedTimeSpanR(value);
 /**
  * Renders the text for a non-modifiable casting time of a fast activatable skill.
  */
-export const renderFastSkillNonModifiableCastingTime = (value) => formatTimeSpanR(Case("Actions"), value.actions);
+export const renderFastSkillNonModifiableCastingTime = (value) => formatTimeSpanR(Case("Actions"), value.actions).thenW(text => appendNoteIfNeeded(value.translations, text));
 /**
  * Get the text for a non-modifiable casting time of a slow activatable skill.
  */
-export const renderSlowSkillNonModifiableCastingTime = (value) => formatCombinedTimeSpanR(value);
+export const renderSlowSkillNonModifiableCastingTime = (value) => formatCombinedTimeSpanR(value).thenW(text => appendNoteIfNeeded(value.translations, text));
 /**
  * Translate casting time.
  */

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

@@ -1,8 +1,7 @@
 import { Reader } from "@elyukai/utils/reader";
-import type { CheckResultBasedModifier, DurationUnitValue, ElvenMagicalSongPermanentCost, FirstPersonMagicalMelodyCost, NonModifiableOneTimeCostPerCountable, NonModifiableSustainedCost, OneTimeCost, OneTimeCostMap, ResponsiveText, ResponsiveTextOptional, ResponsiveTextReplace, SkillModificationLevel_ID, SustainedCost } from "@optolith/database-schema/gen";
-import { type LocaleMap, type Translate } from "../../../../helpers/translate.js";
+import type { CheckResultBasedModifier, DurationUnitValue, ElvenMagicalSongPermanentCost, FirstPersonMagicalMelodyCost, NonModifiableOneTimeCostPerCountable, NonModifiableSustainedCost, OneTimeCost, ResponsiveText, ResponsiveTextOptional, ResponsiveTextReplace, SkillModificationLevel_ID, StandaloneCostMap, SustainedCost } from "@optolith/database-schema/gen";
+import { type LocaleMap } from "../../../../helpers/translate.js";
 import { type StdEnv, type StdReader } from "../../reader.js";
-import { type ResponsiveTextSize } from "../../responsiveText.js";
 /**
  * Returns the text for the modifiable one-time cost of an activatable skill.
  */
@@ -29,7 +28,7 @@ type NonModifiableOneTimeCost = {
 /**
  * Returns the text for a non-modifiable one-time cost of an activatable skill.
  */
-export declare const renderNonModifiableOneTimeCost: (value: NonModifiableOneTimeCost, shouldAppendNonModifiableSuffix: boolean) => StdReader<string, "t" | "tm" | "rts" | "eu" | "nms" | "lj">;
+export declare const renderNonModifiableOneTimeCost: (value: NonModifiableOneTimeCost, shouldAppendNonModifiableSuffix: boolean) => StdReader<string, "t" | "tm" | "f" | "rts" | "eu" | "nms" | "lj">;
 type IndefiniteCost = {
     modifier?: CheckResultBasedModifier;
     translations: LocaleMap<{
@@ -41,27 +40,34 @@ type IndefiniteCost = {
  */
 export declare const renderIndefiniteCost: (value: IndefiniteCost, shouldAppendNonModifiableSuffix: boolean) => StdReader<string, "t" | "tm" | "rts" | "eu" | "nms">;
 /**
- * Returns the text for a one-time cost map of an activatable skill.
+ * Returns the text for a standalone one-time cost map of an activatable skill.
  */
-export declare const renderOneTimeCostMap: (value: OneTimeCostMap) => StdReader<string, "t" | "tm" | "rts" | "nms" | "eu">;
+export declare const renderStandaloneCostMap: (value: StandaloneCostMap) => Reader<StdEnv<"tm" | "t" | "rts"> & {
+    translate: import("../../../../helpers/translate.js").Translate;
+    energyUnit: import("../../units/energy.js").EnergyUnit;
+}, string>;
 /**
  * Returns the text for the cost of a one-time activatable skill.
  */
-export declare const renderOneTimeCost: (value: OneTimeCost) => StdReader<string, "t" | "tm" | "lj" | "rts" | "eu" | "s" | "nms" | "ibi", "SkillModificationLevel">;
+export declare const renderOneTimeCost: (value: OneTimeCost) => StdReader<string, "t" | "tm" | "f" | "lj" | "rts" | "eu" | "s" | "nms" | "ibi", "SkillModificationLevel">;
 /**
  * Returns the text for the non-modifiable cost of a sustained activatable skill.
  */
 export declare const renderNonModifiableSustainedCost: (value: NonModifiableSustainedCost) => Reader<{
-    translate: Translate;
+    translate: import("../../../../helpers/translate.js").Translate;
     energyUnit: import("../../units/energy.js").EnergyUnit;
 } & {
-    translate: Translate;
-    responsiveTextSize: ResponsiveTextSize;
-} & StdEnv<"tm" | "t" | "rts" | "eu", never, never, never>, string>;
+    translate: import("../../../../helpers/translate.js").Translate;
+    responsiveTextSize: import("../../responsiveText.js").ResponsiveTextSize;
+} & {
+    responsiveTextSize: import("../../responsiveText.js").ResponsiveTextSize;
+} & {
+    translate: import("../../../../helpers/translate.js").Translate;
+} & StdEnv<"f" | "tm" | "t" | "rts"> & StdEnv<"tm" | "t" | "rts" | "eu", never, never, never>, string>;
 /**
  * Returns the text for the cost of a sustained activatable skill.
  */
-export declare const renderSustainedCost: (value: SustainedCost) => StdReader<string, "t" | "tm" | "rts" | "eu" | "s" | "nms" | "ibi", "SkillModificationLevel">;
+export declare const renderSustainedCost: (value: SustainedCost) => StdReader<string, "t" | "tm" | "f" | "rts" | "eu" | "s" | "nms" | "ibi", "SkillModificationLevel">;
 type MagicalActionCost = {
     kind: "Fixed";
     Fixed: NonModifiableOneTimeCost;
@@ -86,10 +92,10 @@ type MagicalActionCost = {
     };
 } | {
     kind: "Map";
-    Map: OneTimeCostMap;
+    Map: StandaloneCostMap;
 };
 /**
  * Generates the text for the cost specific to a magical action.
  */
-export declare const renderMagicalActionCost: (cost: MagicalActionCost) => StdReader<string, "t" | "tm" | "rts" | "eu" | "nms" | "lj">;
+export declare const renderMagicalActionCost: (cost: MagicalActionCost) => StdReader<string, "t" | "tm" | "f" | "rts" | "eu" | "nms" | "lj">;
 export {};

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

@@ -2,11 +2,10 @@ import { identity } from "@elyukai/utils/function";
 import { Reader } from "@elyukai/utils/reader";
 import { mapNullable } from "@optolith/helpers/nullable";
 import { assertExhaustive } from "@optolith/helpers/typeSafety";
-import { responsiveTranslate, } from "../../../../helpers/translate.js";
 import { renderResponsiveMap } from "../../map.js";
 import { formatEnergyFnR, formatEnergyR, getInstanceByIdFnR, modifiableBySpeedR, responsiveLocaleJoinR, responsiveR, responsiveTextR, responsiveTranslateR, translateMapR, translateR, } from "../../reader.js";
-import { appendNoteIfNeeded, replaceTextIfNeeded, } from "../../responsiveText.js";
-import { formatCombinedTimeSpan, formatCombinedTimeSpanR } from "../../units/timeSpan.js";
+import { appendNoteIfNeeded, replaceTextIfNeeded } from "../../responsiveText.js";
+import { formatCombinedTimeSpanR } from "../../units/timeSpan.js";
 import { MISSING_VALUE } from "../../unknown.js";
 import { appendCheckResultModifier } from "./checkResultBased.js";
 import { wrapIfMinimum } from "./isMinimumMaximum.js";
@@ -64,12 +63,6 @@ const appendIntervalToCostR = (interval, baseCost) => interval === undefined
         cost: baseCost,
         interval: formattedInterval,
     }));
-const appendIntervalToCost = (translate, responsiveTextSize, interval, baseCost) => interval === undefined
-    ? baseCost
-    : responsiveTranslate(translate, responsiveTextSize, "{$cost} per {$interval}", "{$cost}/{$interval}", {
-        cost: baseCost,
-        interval: formatCombinedTimeSpan(translate, responsiveTextSize, interval, true),
-    });
 /**
  * Returns the text for a non-modifiable one-time cost of an activatable skill.
  */
@@ -77,7 +70,7 @@ export const renderNonModifiableOneTimeCost = (value, shouldAppendNonModifiableS
     .thenW(base => appendFamiliarsTrickLPCostIfNeeded(value.lp_value, base))
     .thenW(base => appendPerCountableToCostIfNeeded(value.per, base))
     .then(base => appendPermanentCostIfNeeded(value.permanent_value, base))
-    .then(base => appendIntervalToCostR(value.interval, base))
+    .thenW(base => appendIntervalToCostR(value.interval, base))
     .then(base => appendElvenPermanentCostIfNeeded(value.permanent, base))
     .then(base => wrapIfMinimum(value.is_minimum, base))
     .then(base => appendNoteIfNeeded(value.translations, base))
@@ -119,22 +112,56 @@ const renderMultipleOneTimeCosts = (type, value) => {
         .then(text => appendNonModifiableIfRequested(text));
 };
 /**
- * Returns the text for a one-time cost map of an activatable skill.
+ * Returns the text for a standalone one-time cost map of an activatable skill.
  */
-export const renderOneTimeCostMap = (value) => Reader.asks(({ translate }) => translate).thenW(translate => formatEnergyFnR
-    .thenW(formatEnergy => renderResponsiveMap(value, option => option.value, formatEnergy, value.options.every(option => option.permanent_value !== undefined)
+export const renderStandaloneCostMap = (value) => renderResponsiveMap(value, option => Reader.of(option.value), formatEnergyR, value.options.every(option => option.value.permanentValue !== undefined)
     ? {
-        surround: values => translate(", {$value} of which are permanent", {
+        surround: values => translateR(", {$value} of which are permanent", {
             value: values,
         }),
         // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- is checked beforehand
-        getAdditionalValue: option => option.permanent_value,
+        getAdditionalValue: option => option.permanentValue,
+    }
+    : undefined);
+/**
+ * Returns the text for a one-time cost map of an activatable skill.
+ */
+const renderOneTimeCostMap = (value) => {
+    switch (value.kind) {
+        case "Modifiable":
+            return renderResponsiveMap(value.Modifiable.map, option => deriveModifiableCost(option.initialModificationLevel).map(cost => cost ?? MISSING_VALUE), formatEnergyR, value.Modifiable.map.options.every(option => option.value.permanentValue !== undefined)
+                ? {
+                    surround: values => translateR(", {$value} of which are permanent", {
+                        value: values,
+                    }),
+                    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- is checked beforehand
+                    getAdditionalValue: option => option.permanentValue,
+                }
+                : undefined);
+        case "NonModifiable":
+            return renderResponsiveMap(value.NonModifiable.map, option => Reader.of(option.value), formatEnergyR, value.NonModifiable.map.options.every(option => option.value.permanentValue !== undefined)
+                ? {
+                    surround: values => translateR(", {$value} of which are permanent", {
+                        value: values,
+                    }),
+                    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- is checked beforehand
+                    getAdditionalValue: option => option.permanentValue,
+                }
+                : undefined).then(text => appendNonModifiableSuffix(ModifiableParameter.Cost, text));
+        default:
+            return assertExhaustive(value);
+    }
+};
+const renderSustainedCostMap = (value) => {
+    switch (value.kind) {
+        case "Modifiable":
+            return renderResponsiveMap(value.Modifiable.map, option => deriveModifiableCost(option.initialModificationLevel).map(cost => cost ?? MISSING_VALUE), singleValue => formatEnergyR(singleValue).thenW(energy => appendIntervalToCostR(value.Modifiable.interval, energy)));
+        case "NonModifiable":
+            return renderResponsiveMap(value.NonModifiable.map, option => Reader.of(option.value), singleValue => formatEnergyR(singleValue).thenW(energy => appendIntervalToCostR(value.NonModifiable.interval, energy))).then(text => appendNonModifiableSuffix(ModifiableParameter.Cost, text));
+        default:
+            return assertExhaustive(value);
     }
-    : undefined))
-    .then(text => appendNonModifiableSuffix(ModifiableParameter.Cost, text)));
-const renderSustainedCostMap = (value) => formatEnergyFnR
-    .thenW(formatEnergy => Reader.ask().thenW(({ translate, responsiveTextSize }) => renderResponsiveMap(value, option => option.value, singleValue => appendIntervalToCost(translate, responsiveTextSize, value.interval, formatEnergy(singleValue)))))
-    .then(text => appendNonModifiableSuffix(ModifiableParameter.Cost, text));
+};
 /**
  * Returns the text for the cost of a one-time activatable skill.
  */
@@ -155,7 +182,7 @@ export const renderOneTimeCost = (value) => {
 const buildSustainedCost = (activationCost, intervalCost, interval) => {
     const activationCostWithLabel = responsiveR(() => translateR("activation").map(label => `${activationCost} (${label})`), () => Reader.of(activationCost)).thenW(identity);
     const intervalCostWithLabel = appendIntervalToCostR(interval, intervalCost);
-    return activationCostWithLabel.map2(intervalCostWithLabel, (activationStr, intervalStr) => `${activationStr} + ${intervalStr}`);
+    return activationCostWithLabel.thenW(activationStr => intervalCostWithLabel.map(intervalStr => `${activationStr} + ${intervalStr}`));
 };
 const renderModifiableSustainedCost = (value) => deriveModifiableCost(value.initial_modification_level).thenW(cost => cost === undefined
     ? Reader.of(MISSING_VALUE)
@@ -173,20 +200,28 @@ export const renderNonModifiableSustainedCost = (value) => formatEnergyFnR
     const getIntervalCost = value.is_minimum === true
         ? responsiveTranslateR("half of the activation cost", "50%")
         : Reader.of(formatEnergy(value.value / 2));
-    return getIntervalCost.then(intervalCost => buildSustainedCost(activationCost, intervalCost, value.interval));
+    return getIntervalCost.thenW(intervalCost => buildSustainedCost(activationCost, intervalCost, value.interval));
 })
     .thenW(base => appendPerCountableToCostIfNeeded(value.per, base))
     .then(base => wrapIfMinimum(value.is_minimum, base))
     .then(base => appendNonModifiableSuffix(ModifiableParameter.Cost, base));
-/**
- * Returns the text for the cost of a sustained activatable skill.
- */
-export const renderSustainedCost = (value) => {
+const renderSingleSustainedCost = (value) => {
     switch (value.kind) {
         case "Modifiable":
             return renderModifiableSustainedCost(value.Modifiable);
         case "NonModifiable":
             return renderNonModifiableSustainedCost(value.NonModifiable);
+        default:
+            return assertExhaustive(value);
+    }
+};
+/**
+ * Returns the text for the cost of a sustained activatable skill.
+ */
+export const renderSustainedCost = (value) => {
+    switch (value.kind) {
+        case "Single":
+            return renderSingleSustainedCost(value.Single);
         case "Map":
             return renderSustainedCostMap(value.Map);
         default:
@@ -220,7 +255,7 @@ export const renderMagicalActionCost = (cost) => {
                     value: cost.All.minimum,
                 }));
         case "Map":
-            return renderOneTimeCostMap(cost.Map);
+            return renderStandaloneCostMap(cost.Map);
         default:
             return assertExhaustive(cost);
     }

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

@@ -4,7 +4,7 @@ import { type StdReader } from "../../reader.js";
 /**
  * Returns the text for a duration that is based on an expression.
  */
-export declare const renderExpressionBasedDuration: (value: ExpressionBasedDuration) => StdReader<string, "t" | "tm" | "rts">;
+export declare const renderExpressionBasedDuration: (value: ExpressionBasedDuration) => StdReader<string, "t" | "tm" | "f" | "rts">;
 type OneTimeDuration = {
     kind: "Immediate";
     Immediate?: Immediate;
@@ -34,11 +34,11 @@ type OneTimeDuration = {
 /**
  * Returns the text for the duration of a one-time activatable skill.
  */
-export declare const renderOneTimeDuration: (value: OneTimeDuration) => StdReader<string, "t" | "tm" | "rts">;
+export declare const renderOneTimeDuration: (value: OneTimeDuration) => StdReader<string, "t" | "tm" | "f" | "rts">;
 /**
  * Returns the text for the duration of a sustained activatable skill.
  */
-export declare const renderSustainedDuration: (value: DurationForSustained | undefined) => StdReader<string, "t" | "rts">;
+export declare const renderSustainedDuration: (value: DurationForSustained | undefined) => StdReader<string, "t" | "tm" | "f" | "rts">;
 /**
  *  Returns the text for the duration of a musical activatable skill.
  */

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

@@ -10,11 +10,11 @@ type RenderedPerformanceParameters = {
 /**
  * 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">;
+export declare const renderFastOneTimePerformanceParameters: (value: FastOneTimePerformanceParameters) => StdReader<RenderedPerformanceParameters, "t" | "tm" | "f" | "lj" | "eu" | "rts" | "nms" | "ibi", "SkillModificationLevel">;
 /**
  * Get the texts for all fast sustained performance parameters.
  */
-export declare const renderFastSustainedPerformanceParameters: (value: FastSustainedPerformanceParameters) => StdReader<RenderedPerformanceParameters, "t" | "tm" | "lj" | "eu" | "rts" | "nms" | "ibi", "SkillModificationLevel">;
+export declare const renderFastSustainedPerformanceParameters: (value: FastSustainedPerformanceParameters) => StdReader<RenderedPerformanceParameters, "t" | "tm" | "f" | "lj" | "eu" | "rts" | "nms" | "ibi", "SkillModificationLevel">;
 /**
  * Renders the performance parameters for a fast activatable skill.
  */
@@ -24,15 +24,15 @@ export declare const renderFastPerformanceParameters: (value: {
 } | {
     kind: "Sustained";
     Sustained: FastSustainedPerformanceParameters;
-}) => StdReader<RenderedPerformanceParameters, "t" | "tm" | "lj" | "eu" | "rts" | "nms" | "ibi", "SkillModificationLevel">;
+}) => StdReader<RenderedPerformanceParameters, "t" | "tm" | "f" | "lj" | "eu" | "rts" | "nms" | "ibi", "SkillModificationLevel">;
 /**
  * Get the texts for all slow one-time performance parameters.
  */
-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">;
+export declare const renderSlowOneTimePerformanceParameters: <CastingTime>(renderCastingTime: (value: CastingTime) => StdReader<string, "t" | "tm" | "f" | "rts" | "nms" | "ibi", "SkillModificationLevel">, value: OneTimePerformanceParameters<CastingTime>) => StdReader<RenderedPerformanceParameters, "t" | "tm" | "f" | "lj" | "eu" | "rts" | "nms" | "ibi", "SkillModificationLevel">;
 /**
  * Get the texts for all slow sustained performance parameters.
  */
-export declare const renderSlowSustainedPerformanceParameters: (value: SlowSustainedPerformanceParameters) => StdReader<RenderedPerformanceParameters, "t" | "tm" | "lj" | "eu" | "rts" | "nms" | "ibi", "SkillModificationLevel">;
+export declare const renderSlowSustainedPerformanceParameters: (value: SlowSustainedPerformanceParameters) => StdReader<RenderedPerformanceParameters, "t" | "tm" | "f" | "lj" | "eu" | "rts" | "nms" | "ibi", "SkillModificationLevel">;
 /**
  * Renders the performance parameters for a slow activatable skill.
  */
@@ -42,7 +42,7 @@ export declare const renderSlowPerformanceParameters: (value: {
 } | {
     kind: "Sustained";
     Sustained: SlowSustainedPerformanceParameters;
-}) => StdReader<RenderedPerformanceParameters, "t" | "tm" | "lj" | "eu" | "rts" | "nms" | "ibi", "SkillModificationLevel">;
+}) => StdReader<RenderedPerformanceParameters, "t" | "tm" | "f" | "lj" | "eu" | "rts" | "nms" | "ibi", "SkillModificationLevel">;
 /**
  * Diff the generated text with the static translation and combine them into a single text, highlighting the differences.
  */

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

@@ -9,7 +9,7 @@ import { Speed } from "./speed.js";
  * Get the texts for all fast one-time performance parameters.
  */
 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 => ({
+    .thenW(castingTime => renderOneTimeCost(value.cost).then(cost => renderRange(value.range).thenW(range => renderOneTimeDuration(value.duration).map(duration => ({
     castingTime,
     cost,
     range,
@@ -20,7 +20,7 @@ export const renderFastOneTimePerformanceParameters = (value) => renderFastCasti
  * Get the texts for all fast sustained performance parameters.
  */
 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 => ({
+    .thenW(castingTime => renderSustainedCost(value.cost).then(cost => renderRange(value.range).thenW(range => renderSustainedDuration(value.duration).map(duration => ({
     castingTime,
     cost,
     range,
@@ -44,7 +44,7 @@ export const renderFastPerformanceParameters = (value) => {
  * Get the texts for all slow one-time performance parameters.
  */
 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 => ({
+    .thenW(castingTime => renderOneTimeCost(value.cost).then(cost => renderRange(value.range).thenW(range => renderOneTimeDuration(value.duration).map(duration => ({
     castingTime,
     cost,
     range,
@@ -55,7 +55,7 @@ export const renderSlowOneTimePerformanceParameters = (renderCastingTime, value)
  * Get the texts for all slow sustained performance parameters.
  */
 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 => ({
+    .thenW(castingTime => renderSustainedCost(value.cost).then(cost => renderRange(value.range).thenW(range => renderSustainedDuration(value.duration).map(duration => ({
     castingTime,
     cost,
     range,

package/lib/entities/partial/reader.d.ts

@@ -147,6 +147,16 @@ export declare const attributedNameR: <E extends { [K in keyof EntityMap]: Entit
     translateMap: TranslateMap;
     getInstanceById: GetInstanceById<E>;
 }, string | undefined>;
+/**
+ * Retrieves the `name` property of the specified entry in an attributed string.
+ */
+export declare const attributedNameFromInstanceR: (instance: {
+    translations: LocaleMap<{
+        name: string;
+    }>;
+} | undefined, context: string, ...args: IdArgsVariant) => Reader<{
+    translateMap: TranslateMap;
+}, string | undefined>;
 /**
  * Applies a function to the translation of the specified entry and renders it in an attributed string.
  */

package/lib/entities/partial/reader.js

@@ -1,7 +1,7 @@
 import { isNotNullish } from "@elyukai/utils/nullable";
 import { Reader } from "@elyukai/utils/reader";
 import { assertExhaustive } from "@elyukai/utils/typeSafety";
-import { attributedCustomName, attributedName, customName } from "./markdown.js";
+import { attributedCustomName, attributedName, attributedNameFromInstance, customName, } from "./markdown.js";
 import { Speed } from "./rated/activatable/speed.js";
 import { responsive, ResponsiveTextSize } from "./responsiveText.js";
 import { formatEnergy } from "./units/energy.js";
@@ -55,6 +55,10 @@ export const strictNameR = (...args) => nameR(...args).map(name => name ?? MISSI
  * Retrieves the `name` property of the specified entry in an attributed string.
  */
 export const attributedNameR = (context, ...args) => Reader.asks(env => attributedName(env.translateMap, env.getInstanceById, context, ...args));
+/**
+ * Retrieves the `name` property of the specified entry in an attributed string.
+ */
+export const attributedNameFromInstanceR = (instance, context, ...args) => Reader.asks(env => attributedNameFromInstance(env.translateMap, instance, context, ...args));
 /**
  * Applies a function to the translation of the specified entry and renders it in an attributed string.
  */

package/lib/entities/partial/units/timeSpan.d.ts

@@ -1,5 +1,6 @@
 import { Reader } from "@elyukai/utils/reader";
-import type { Translate } from "../../../helpers/translate.js";
+import type { Case } from "tsondb/schema/gen";
+import type { Format, LocaleMap, Translate, TranslateMap } from "../../../helpers/translate.js";
 import type { StdEnv } from "../reader.js";
 import { type ResponsiveTextSize } from "../responsiveText.js";
 /**
@@ -7,32 +8,39 @@ import { type ResponsiveTextSize } from "../responsiveText.js";
  */
 export type TimeSpanUnit = "Seconds" | "Minutes" | "Hours" | "Days" | "Weeks" | "Months" | "Years" | "Decades" | "Centuries" | "Actions" | "CombatRounds" | "SeductionActions" | "Rounds";
 /**
- * Returns the text for a time span unit.
+ * Possible units to use for time spans, including the possibility of creating your own.
  */
-export declare const formatTimeSpan: (translate: Translate, responsiveTextSize: ResponsiveTextSize, unit: {
+export type TimeSpanUnitObject = {
     kind: TimeSpanUnit;
-} | TimeSpanUnit, value: number | string, interval?: boolean) => string;
+} | Case<"Custom", {
+    translations: LocaleMap<{
+        name: string;
+        symbol: string;
+        fullNumber: string;
+        full: string;
+        compressedNumber: string;
+        compressed: string;
+    }>;
+}>;
 /**
  * Returns the text for a time span unit.
  */
-export declare const formatCombinedTimeSpan: (translate: Translate, responsiveTextSize: ResponsiveTextSize, object: {
-    unit: {
-        kind: TimeSpanUnit;
-    };
+export declare const formatTimeSpan: (translate: Translate, translateMap: TranslateMap, format: Format, responsiveTextSize: ResponsiveTextSize, unit: TimeSpanUnitObject | TimeSpanUnit, value: number | string, interval?: boolean) => string;
+/**
+ * Returns the text for a time span unit.
+ */
+export declare const formatCombinedTimeSpan: (translate: Translate, translateMap: TranslateMap, format: Format, responsiveTextSize: ResponsiveTextSize, object: {
+    unit: TimeSpanUnitObject;
     value: number | string;
 }, interval?: boolean) => string;
 /**
  * Returns the text for a time span unit.
  */
-export declare const formatTimeSpanR: (unit: {
-    kind: TimeSpanUnit;
-} | TimeSpanUnit, value: number | string, interval?: boolean) => Reader<StdEnv<"t" | "rts">, string>;
+export declare const formatTimeSpanR: (unit: TimeSpanUnitObject | TimeSpanUnit, value: number | string, interval?: boolean) => Reader<StdEnv<"t" | "tm" | "f" | "rts">, string>;
 /**
  * Returns the text for a time span unit.
  */
 export declare const formatCombinedTimeSpanR: (object: {
-    unit: {
-        kind: TimeSpanUnit;
-    };
+    unit: TimeSpanUnitObject;
     value: number | string;
-}, interval?: boolean) => Reader<StdEnv<"t" | "rts">, string>;
+}, interval?: boolean) => Reader<StdEnv<"t" | "tm" | "f" | "rts">, string>;