@optolith/entity-descriptions 0.2.0 → 0.3.1

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

@@ -1,8 +1,7 @@
-import { TargetCategory } from "optolith-database-schema/types/_ActivatableSkillTargetCategory";
-import { GetById } from "../../../../helpers/getTypes.js";
-import { LocaleEnvironment } from "../../../../helpers/locale.js";
-import { EntityDescriptionSection } from "../../../../index.js";
+import type { AffectedTargetCategories } from "optolith-database-schema/gen";
+import { type RawDefinitionListEntityDescriptionSectionItem } from "../../../../index.js";
+import { type StdReader } from "../../reader.js";
 /**
  * Get the text for the target category.
  */
-export declare const getTargetCategoryTranslation: (getTargetCategoryById: GetById.Static.TargetCategory, locale: LocaleEnvironment, values: TargetCategory) => EntityDescriptionSection;
+export declare const renderTargetCategory: (values: AffectedTargetCategories) => StdReader<RawDefinitionListEntityDescriptionSectionItem, "t" | "tm" | "ibi", "TargetCategory">;

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

@@ -1,28 +1,26 @@
+import { Reader } from "@elyukai/utils/reader";
 import { mapNullable } from "@optolith/helpers/nullable";
 import { assertExhaustive } from "@optolith/helpers/typeSafety";
+import { getInstanceByIdFnR, translateMapR, translateR, } from "../../reader.js";
 import { MISSING_VALUE } from "../../unknown.js";
 import { appendInParensIfNotEmpty } from "./parensIf.js";
-const getSelfTranslation = (locale) => locale.translate("Self");
-const getZoneTranslation = (locale) => locale.translate("Zone");
-const getLiturgicalChantsAndCeremoniesTranslation = (locale) => locale.translate("Liturgical Chants and Ceremonies");
-const getCantripsTranslation = (locale) => locale.translate("Cantrips");
-const getPredefinedTranslation = (getTargetCategoryById, locale, value) => {
-    const numericId = value.id.target_category;
-    const specificTargetCategory = getTargetCategoryById(numericId);
-    return (mapNullable(locale.translateMap(specificTargetCategory?.translations), (translation) => translation.name) ?? MISSING_VALUE);
-};
-const getTargetCategoryTranslationByType = (getTargetCategoryById, locale, id) => {
-    switch (id.tag) {
+const renderPredefined = (targetCategoryId) => getInstanceByIdFnR()
+    .thenW(getInstanceById => mapNullable(getInstanceById("TargetCategory", targetCategoryId), targetCategory => translateMapR(targetCategory.translations).map(translation => translation?.name)) ?? Reader.of(undefined))
+    .map(translation => translation ?? MISSING_VALUE);
+const getTargetCategoryTranslationByType = (id) => {
+    switch (id.kind) {
         case "Self":
-            return getSelfTranslation(locale);
+            return translateR("Self");
         case "Zone":
-            return getZoneTranslation(locale);
+            return translateR("Zone");
         case "LiturgicalChantsAndCeremonies":
-            return getLiturgicalChantsAndCeremoniesTranslation(locale);
+            return translateR("Liturgical Chants and Ceremonies");
+        case "Spellworks":
+            return translateR("Spellworks");
         case "Cantrips":
-            return getCantripsTranslation(locale);
+            return translateR("Cantrips");
         case "Predefined":
-            return getPredefinedTranslation(getTargetCategoryById, locale, id.predefined);
+            return renderPredefined(id.Predefined);
         default:
             return assertExhaustive(id);
     }
@@ -30,11 +28,8 @@ const getTargetCategoryTranslationByType = (getTargetCategoryById, locale, id) =
 /**
  * Get the text for the target category.
  */
-export const getTargetCategoryTranslation = (getTargetCategoryById, locale, values) => ({
-    label: locale.translate("Target Category"),
-    value: values.length === 0
-        ? locale.translate("all")
-        : values
-            .map(({ id, translations }) => appendInParensIfNotEmpty(locale.translateMap(translations)?.note, getTargetCategoryTranslationByType(getTargetCategoryById, locale, id)))
-            .join(", "),
-});
+export const renderTargetCategory = (values) => translateR("Target Category").thenW(label => (values.length === 0
+    ? translateR("all")
+    : Reader.sequence(values.map(({ id, translations }) => getTargetCategoryTranslationByType(id).then(text => translateMapR(translations)
+        .map(translation => translation?.note)
+        .map(note => appendInParensIfNotEmpty(note, text)) ?? text))).map(texts => texts.join(", "))).map(value => ({ label, value })));

package/lib/entities/partial/rated/improvementCost.d.ts

@@ -1,7 +1,19 @@
-import { ImprovementCost as RawImprovementCost } from "optolith-database-schema/types/_ImprovementCost";
-import { Translate } from "../../../helpers/translate.js";
-import { EntityDescriptionSection } from "../../../index.js";
+import { type RangeBounds } from "@elyukai/utils/range";
+import type { ImprovementCost } from "optolith-database-schema/gen";
+import { type RawDefinitionListEntityDescriptionSectionItem } from "../../../index.js";
+import { type StdReader } from "../reader.js";
+/**
+ * Renders an improvement cost value as a string.
+ */
+export declare const renderImprovementCostValue: (improvementCost: ImprovementCost) => string;
 /**
  * Returns the improvement cost as an inline library property.
  */
-export declare const createImprovementCost: (translate: Translate, improvementCost: RawImprovementCost) => EntityDescriptionSection;
+export declare const renderImprovementCost: (improvementCost: ImprovementCost) => StdReader<RawDefinitionListEntityDescriptionSectionItem, "t">;
+/**
+ * Calculates the adventure points for an improvement cost.
+ * @throws {RangeError} if the rating range is invalid (max < min).
+ */
+export declare const calculateAdventurePointsFromImprovementCost: (improvementCost: ImprovementCost | ImprovementCost["kind"] | {
+    kind: "E";
+} | "E", rating?: number | RangeBounds) => number;

package/lib/entities/partial/rated/improvementCost.js

@@ -1,7 +1,66 @@
+import { rangeSize } from "@elyukai/utils/range";
+import { assertExhaustive } from "@elyukai/utils/typeSafety";
+import { translateR } from "../reader.js";
+/**
+ * Renders an improvement cost value as a string.
+ */
+export const renderImprovementCostValue = (improvementCost) => improvementCost.kind;
 /**
  * Returns the improvement cost as an inline library property.
  */
-export const createImprovementCost = (translate, improvementCost) => ({
-    label: translate("Improvement Cost"),
-    value: improvementCost,
-});
+export const renderImprovementCost = (improvementCost) => translateR("Improvement Cost").map(label => ({
+    label,
+    value: renderImprovementCostValue(improvementCost),
+}));
+/**
+ * Calculates the adventure points for an improvement cost.
+ * @throws {RangeError} if the rating range is invalid (max < min).
+ */
+export const calculateAdventurePointsFromImprovementCost = (improvementCost, rating = 1) => {
+    const normalized = typeof improvementCost === "string" ? improvementCost : improvementCost.kind;
+    const base = (() => {
+        switch (normalized) {
+            case "A":
+                return 1;
+            case "B":
+                return 2;
+            case "C":
+                return 3;
+            case "D":
+                return 4;
+            case "E":
+                return 15;
+            default:
+                return assertExhaustive(normalized);
+        }
+    })();
+    const lastRatingOfSameValue = (() => {
+        switch (normalized) {
+            case "A":
+            case "B":
+            case "C":
+            case "D":
+                return 12;
+            case "E":
+                return 14;
+            default:
+                return assertExhaustive(normalized);
+        }
+    })();
+    if (typeof rating === "number") {
+        return (base *
+            (rating < lastRatingOfSameValue ? 1 : rating - lastRatingOfSameValue + 1));
+    }
+    else {
+        const [min, max] = rating;
+        if (max < min) {
+            throw new RangeError(`Invalid rating range: ${min} - ${max}`);
+        }
+        const size = rangeSize(rating);
+        const constantRangeSize = Math.min(size, lastRatingOfSameValue - min + 1);
+        const variableRangeSize = size - constantRangeSize;
+        const constantCost = base * constantRangeSize;
+        const variableCost = base * (((variableRangeSize + 1) * (variableRangeSize + 2)) / 2 - 1);
+        return constantCost + variableCost;
+    }
+};

package/lib/entities/partial/rated/skillCheck.d.ts

@@ -1,19 +1,22 @@
-import { SkillCheck, SkillCheckPenalty } from "optolith-database-schema/types/_SkillCheck";
-import { DerivedCharacteristic } from "optolith-database-schema/types/DerivedCharacteristic";
-import { GetById } from "../../../helpers/getTypes.js";
-import { Translate, TranslateMap } from "../../../helpers/translate.js";
-import { EntityDescriptionSection } from "../../../index.js";
-import { ResponsiveTextSize } from "../responsiveText.js";
+import type { SkillCheckPenalty as GeneralSkillCheckPenalty, MagicalRuneCombatTechniqueCheckPenalty, SkillCheck } from "optolith-database-schema/gen";
+import { type IdMap } from "../../../index.js";
+import { type StdReader } from "../reader.js";
 /**
- * Returns the skill check as an inline library property.
+ * Renders a skill check.
  */
-export declare const getTextForCheck: (deps: {
-    translate: Translate;
-    translateMap: TranslateMap;
-    getAttributeById: GetById.Static.Attribute;
-}, check: SkillCheck, checkPenalty?: {
-    value: SkillCheckPenalty | undefined;
-    responsiveText: ResponsiveTextSize;
-    getSpirit: () => DerivedCharacteristic | undefined;
-    getToughness: () => DerivedCharacteristic | undefined;
-}) => EntityDescriptionSection;
+export declare const renderSkillCheck: (check: SkillCheck) => StdReader<{
+    label: string;
+    value: string;
+}, "t" | "tm" | "ibi", "Attribute">;
+type SkillCheckPenalty = GeneralSkillCheckPenalty | {
+    kind: "CombatTechnique";
+    CombatTechnique: MagicalRuneCombatTechniqueCheckPenalty;
+};
+/**
+ * Renders a skill check with a possible penalty.
+ */
+export declare const renderSkillCheckWithPenalty: (check: SkillCheck, checkPenalty: SkillCheckPenalty | undefined, idMap: IdMap) => StdReader<{
+    label: string;
+    value: string;
+}, "t" | "tm" | "rts" | "ibi", "Attribute" | "DerivedCharacteristic">;
+export {};

package/lib/entities/partial/rated/skillCheck.js

@@ -1,58 +1,60 @@
+import { Reader } from "@elyukai/utils/reader";
 import { assertExhaustive } from "@optolith/helpers/typeSafety";
-import { responsive } from "../responsiveText.js";
+import { getInstanceByIdFnR, responsiveR, responsiveThenR, responsiveTranslateR, translateMapR, translateR, } from "../reader.js";
+import { MISSING_VALUE } from "../unknown.js";
 /**
- * Returns the skill check as an inline library property.
+ * Renders a skill check.
  */
-export const getTextForCheck = (deps, check, checkPenalty) => ({
-    label: deps.translate("Check"),
+export const renderSkillCheck = (check) => Reader.asks(({ translate, translateMap, getInstanceById }) => ({
+    label: translate("Check"),
     value: check
-        .map(({ id: { attribute: id } }) => deps.translateMap(deps.getAttributeById(id)?.translations)
-        ?.abbreviation ?? "??")
-        .join("/") +
-        (() => {
-            if (checkPenalty?.value === undefined) {
-                return "";
-            }
-            const { responsiveText } = checkPenalty;
-            const getDerivedCharacteristicTranslation = (getDerivedCharacteristic) => deps.translateMap(getDerivedCharacteristic()?.translations);
-            const getSpiritTranslation = () => getDerivedCharacteristicTranslation(checkPenalty.getSpirit);
-            const getToughnessTranslation = () => getDerivedCharacteristicTranslation(checkPenalty.getToughness);
-            const penalty = (() => {
-                switch (checkPenalty.value) {
-                    case "Spirit": {
-                        const translation = getSpiritTranslation();
-                        return translation === undefined
-                            ? ""
-                            : responsive(responsiveText, () => translation.name, () => translation.abbreviation);
-                    }
-                    case "HalfOfSpirit": {
-                        const translation = getSpiritTranslation();
-                        return translation === undefined
-                            ? ""
-                            : responsive(responsiveText, () => `${translation.name}/2`, () => `${translation.abbreviation}/2`);
-                    }
-                    case "Toughness": {
-                        const translation = getToughnessTranslation();
-                        return translation === undefined
-                            ? ""
-                            : responsive(responsiveText, () => `${translation.name}/2`, () => `${translation.abbreviation}/2`);
-                    }
-                    case "HigherOfSpiritAndToughness": {
-                        const spiritTranslation = getSpiritTranslation();
-                        const toughnessTranslation = getToughnessTranslation();
-                        return spiritTranslation === undefined ||
-                            toughnessTranslation === undefined
-                            ? ""
-                            : responsive(responsiveText, () => deps.translate("{0} or {1}, depending on which value is higher", spiritTranslation.abbreviation, toughnessTranslation.abbreviation), () => `${spiritTranslation.abbreviation}/${toughnessTranslation.abbreviation}`);
-                    }
-                    case "SummoningDifficulty":
-                        return responsive(responsiveText, () => deps.translate("Invocation Difficulty"), () => deps.translate("ID"));
-                    case "CreationDifficulty":
-                        return responsive(responsiveText, () => deps.translate("Creation Difficulty"), () => deps.translate("CD"));
-                    default:
-                        return assertExhaustive(checkPenalty.value);
-                }
-            })();
-            return responsive(responsiveText, () => deps.translate(" (modified by {0})", penalty), () => deps.translate(" (− {0})", penalty));
-        })(),
-});
+        .map(id => translateMap(getInstanceById("Attribute", id)?.translations)
+        ?.abbreviation ?? MISSING_VALUE)
+        .join("/"),
+}));
+const renderSkillCheckPenalty = (idMap, penalty) => {
+    const getDerivedCharacteristicTranslation = (id) => getInstanceByIdFnR()
+        .map(getInstanceById => getInstanceById("DerivedCharacteristic", id))
+        .thenW(dc => dc === undefined
+        ? Reader.of(undefined)
+        : translateMapR(dc.translations).thenW(translation => translation === undefined
+            ? Reader.of(undefined)
+            : responsiveR(() => translation.name, () => translation.abbreviation)))
+        .map(translation => translation ?? MISSING_VALUE);
+    const getSpiritTranslation = () => getDerivedCharacteristicTranslation(idMap.DerivedCharacteristic.Spirit);
+    const getToughnessTranslation = () => getDerivedCharacteristicTranslation(idMap.DerivedCharacteristic.Toughness);
+    switch (penalty.kind) {
+        case "Spirit":
+            return getSpiritTranslation();
+        case "HalfOfSpirit":
+            return getSpiritTranslation().map(translation => `${translation}/2`);
+        case "Toughness":
+            return getToughnessTranslation();
+        case "HigherOfSpiritAndToughness":
+            return getSpiritTranslation().thenW(spirit => getToughnessTranslation().thenW(toughness => responsiveThenR(() => translateR("{$first} or {$second}, depending on which value is higher", {
+                first: spirit,
+                second: toughness,
+            }), () => Reader.of(`${spirit}/${toughness}`))));
+        case "SummoningDifficulty":
+            return responsiveTranslateR("Invocation Difficulty", "ID");
+        case "CreationDifficulty":
+            return responsiveTranslateR("Creation Difficulty", "CD");
+        case "Object":
+            return translateR("Object");
+        case "CombatTechnique":
+            return responsiveTranslateR("Combat Technique", "CT");
+        default:
+            return assertExhaustive(penalty);
+    }
+};
+/**
+ * Renders a skill check with a possible penalty.
+ */
+export const renderSkillCheckWithPenalty = (check, checkPenalty, idMap) => checkPenalty === undefined
+    ? renderSkillCheck(check)
+    : renderSkillCheck(check).thenW(checkText => renderSkillCheckPenalty(idMap, checkPenalty)
+        .then(penaltyText => responsiveTranslateR(" (modified by {$modifier})", " (−{$modifier})", { modifier: penaltyText }))
+        .map(penaltyText => ({
+        ...checkText,
+        value: checkText.value + penaltyText,
+    })));

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

@@ -0,0 +1,266 @@
+import { Reader } from "@elyukai/utils/reader";
+import type { ChildEntityMap, EntityMap, FastSkillModificationLevelConfig, ResponsiveText, ResponsiveTextOptional, SkillModificationLevel, SlowSkillModificationLevelConfig } from "optolith-database-schema/gen";
+import type { IdArgsVariant } from "tsondb/schema/gen";
+import type { GetAllChildInstancesForParent, GetAllInstances, GetInstanceById } from "../../helpers/getTypes.js";
+import type { LocaleCompare, LocaleJoin, LocaleJoinType } from "../../helpers/locale.js";
+import type { Format, LocaleMap, Translate, TranslateMap, TranslationKeyMatchingParamsOfKey, TranslationKeysWithoutParams, TranslationParamsInArray, Translations } from "../../helpers/translate.js";
+import type { GetResolvedSelectOptionById } from "./prerequisites/single/activatable.js";
+import type { ModifiableParameter } from "./rated/activatable/nonModifiableSuffix.js";
+import { Speed } from "./rated/activatable/speed.js";
+import { ResponsiveTextSize } from "./responsiveText.js";
+import { type EnergyUnit } from "./units/energy.js";
+/**
+ * The standard set of environment properties for readers in this project.
+ */
+export type EnvMap<E extends keyof EntityMap = never, AE extends keyof EntityMap = never, CE extends keyof ChildEntityMap = never> = {
+    format: Format;
+    translate: Translate;
+    translateMap: TranslateMap;
+    localeJoin: LocaleJoin;
+    localeCompare: LocaleCompare;
+    responsiveTextSize: ResponsiveTextSize;
+    speed: Speed;
+    energyUnit: EnergyUnit;
+    nonModifiableSuffix?: (param: ModifiableParameter) => TranslationKeysWithoutParams;
+    getInstanceById: GetInstanceById<E>;
+    getAllInstances: GetAllInstances<AE>;
+    getChildInstancesForInstanceId: GetAllChildInstancesForParent<CE>;
+    getResolvedSelectOptionById: GetResolvedSelectOptionById;
+};
+/**
+ * Shortcuts for selecting keys of the shared environment map type.
+ */
+export type EnvMapAbbr = {
+    f: "format";
+    t: "translate";
+    tm: "translateMap";
+    lj: "localeJoin";
+    lc: "localeCompare";
+    rts: "responsiveTextSize";
+    s: "speed";
+    eu: "energyUnit";
+    nms: "nonModifiableSuffix";
+    ibi: "getInstanceById";
+    ai: "getAllInstances";
+    acibp: "getChildInstancesForInstanceId";
+    rso: "getResolvedSelectOptionById";
+};
+/**
+ * The standard set of environment properties for readers in this project.
+ *
+ * The keys are abbreviated to keep type annotations short.
+ */
+export type StdEnv<K extends keyof EnvMapAbbr = keyof EnvMapAbbr, E extends keyof EntityMap = never, AE extends keyof EntityMap = never, CE extends keyof ChildEntityMap = never> = Pick<EnvMap<E, AE, CE>, EnvMapAbbr[K]>;
+/**
+ * Shortcut for a reader with common environment properties.
+ *
+ * The keys are abbreviated to keep return type annotations short.
+ */
+export type StdReader<T, K extends keyof EnvMapAbbr, E extends keyof EntityMap = never, AE extends keyof EntityMap = never, CE extends keyof ChildEntityMap = never> = Reader<StdEnv<K, E, AE, CE>, T>;
+/**
+ * Treats the text as a translation string and applies supplied arguments.
+ */
+export declare const formatR: (text: string, args?: Record<string, unknown> | undefined) => Reader<{
+    format: Format;
+}, string>;
+/**
+ * Creates a value from a translation key.
+ */
+export declare const translateR: <K extends keyof Translations>(key: K, ...rest: TranslationParamsInArray<K>) => Reader<{
+    translate: Translate;
+}, string>;
+/**
+ * Returns the `translate` function from the context.
+ */
+export declare const translateFnR: Reader<{
+    translate: Translate;
+}, Translate>;
+/**
+ * Takes the appropriate translation from a locale map.
+ */
+export declare const translateMapR: <T>(map: LocaleMap<T> | undefined) => Reader<{
+    translateMap: TranslateMap;
+}, T | undefined>;
+/**
+ * Returns the `translateMap` function from the context.
+ */
+export declare const translateMapFnR: Reader<{
+    translateMap: TranslateMap;
+}, TranslateMap>;
+/**
+ * Retrieves the translation for the current locale from the given value’s `translations` property.
+ * @returns `undefined` if the value does not exist or does not have a translation for the current locale, otherwise the translation.
+ */
+export declare const translationR: <T>(value: {
+    translations?: LocaleMap<T>;
+} | undefined) => Reader<{
+    translateMap: TranslateMap;
+}, T | undefined>;
+/**
+ * Retrieves a specific property of the specified entry.
+ */
+export declare const mapTranslationR: <E extends keyof EntityMap & { [K in keyof EntityMap]: EntityMap[K] extends {
+    translations: LocaleMap<object>;
+} ? K : never; }[keyof EntityMap], R>(...args: [...IdArgsVariant<EntityMap, E>, fn: (translation: EntityMap[E] extends {
+    translations: LocaleMap<infer T>;
+} ? T | undefined : never) => R]) => Reader<{
+    translateMap: TranslateMap;
+    getInstanceById: GetInstanceById<E>;
+}, R | undefined>;
+/**
+ * Retrieves the `name` property of the specified entry.
+ */
+export declare const nameR: <E extends { [K in keyof EntityMap]: EntityMap[K] extends {
+    translations: LocaleMap<{
+        name: string;
+    }>;
+} ? K : never; }[keyof EntityMap]>(...args: IdArgsVariant<EntityMap, E>) => Reader<{
+    translateMap: TranslateMap;
+    getInstanceById: GetInstanceById<E>;
+}, string | undefined>;
+/**
+ * Retrieves the `name` property of the specified entry.
+ *
+ * Returns {@link MISSING_VALUE} if there is no name for the entry in the locale. This can happen if the entry itself does not exist, or it does not have a translation for the current locale.
+ */
+export declare const strictNameR: <E extends { [K in keyof EntityMap]: EntityMap[K] extends {
+    translations: LocaleMap<{
+        name: string;
+    }>;
+} ? K : never; }[keyof EntityMap]>(...args: IdArgsVariant<EntityMap, E>) => Reader<{
+    translateMap: TranslateMap;
+    getInstanceById: GetInstanceById<E>;
+}, string>;
+/**
+ * Joins a list of strings according to the locale’s rules for the given type.
+ */
+export declare const localeJoinR: (arr: string[], type: LocaleJoinType) => Reader<{
+    localeJoin: LocaleJoin;
+}, string>;
+/**
+ * Returns a function to retrieve an instance from the database by its entity name and ID.
+ */
+export declare const getInstanceByIdFnR: <E extends keyof EntityMap = never>() => Reader<{
+    getInstanceById: GetInstanceById<E>;
+}, GetInstanceById<E>>;
+/**
+ * Retrieves an instance from the database by its entity name and ID.
+ */
+export declare const getInstanceByIdR: <E extends keyof EntityMap>(...args: IdArgsVariant<EntityMap, E>) => Reader<{
+    getInstanceById: GetInstanceById<E>;
+}, EntityMap[E] | undefined>;
+/**
+ * Retrieves all instances of an entity from the database by their entity name.
+ */
+export declare const getAllInstancesR: <E extends keyof EntityMap>(entityName: E) => Reader<{
+    getAllInstances: GetAllInstances<E>;
+}, {
+    id: string;
+    content: EntityMap[E];
+}[]>;
+/**
+ * Retrieves all child instances of an entity from the database by their child entity name and their parent’s identifier.
+ */
+export declare const getChildInstancesForInstanceIdR: <CE extends keyof ChildEntityMap>(entityName: CE, parentId: ChildEntityMap[CE][2]) => Reader<{
+    getChildInstancesForInstanceId: GetAllChildInstancesForParent<CE>;
+}, {
+    id: string;
+    content: ChildEntityMap[CE][0];
+}[]>;
+/**
+ * Joins a list of strings according to the locale’s rules for the given type.
+ */
+export declare const responsiveLocaleJoinR: (arr: string[], type: LocaleJoinType) => Reader<{
+    localeJoin: LocaleJoin;
+    responsiveTextSize: ResponsiveTextSize;
+}, string>;
+/**
+ * Compares two strings according to the locale’s sorting rules.
+ */
+export declare const localeCompareR: Reader<{
+    localeCompare: LocaleCompare;
+}, LocaleCompare>;
+/**
+ * Sorts an array of strings according to the locale’s sorting rules.
+ */
+export declare const localeSortR: <T extends string>(arr: T[]) => Reader<{
+    localeCompare: LocaleCompare;
+}, T[]>;
+/**
+ * Creates a responsive value from two functions that return the value for the full and compressed version, respectively.
+ */
+export declare const responsiveR: <T>(full: () => T, compressed: () => T) => Reader<{
+    responsiveTextSize: ResponsiveTextSize;
+}, T>;
+/**
+ * Creates a responsive value from two functions that return the value for the full and compressed version, respectively.
+ */
+export declare const responsiveThenR: <T, RF extends object, RC extends object>(full: () => Reader<RF, T>, compressed: () => Reader<RC, T>) => Reader<{
+    responsiveTextSize: ResponsiveTextSize;
+} & RF & RC, T>;
+/**
+ * Creates a responsive value from a translation key that has a full and a compressed version.
+ */
+export declare const responsiveTranslateR: <K extends keyof Translations, K2 extends TranslationKeyMatchingParamsOfKey<K>>(fullKey: K, compressedKey: K2, ...rest: TranslationParamsInArray<K> & TranslationParamsInArray<K2>) => Reader<{
+    translate: Translate;
+    responsiveTextSize: ResponsiveTextSize;
+}, string>;
+/**
+ * Creates a responsive value from a responsive text.
+ */
+export declare const responsiveTextR: (responsiveText: ResponsiveText) => Reader<{
+    responsiveTextSize: ResponsiveTextSize;
+}, string>;
+/**
+ * Creates a responsive value from a responsive text with an optional compressed variant.
+ */
+export declare const responsiveTextOptionalR: (responsiveText: ResponsiveTextOptional) => Reader<{
+    responsiveTextSize: ResponsiveTextSize;
+}, string | undefined>;
+/**
+ * Formats the given energy cost value with the appropriate unit.
+ */
+export declare const formatEnergyR: (value: string | number) => Reader<{
+    translate: Translate;
+    energyUnit: EnergyUnit;
+}, string>;
+/**
+ * Formats the given energy cost value with the appropriate unit based on the entity type.
+ */
+export declare const formatEnergyFnR: Reader<{
+    translate: Translate;
+    energyUnit: EnergyUnit;
+}, (value: string | number) => string>;
+type SpeedMap = {
+    [Speed.Fast]: FastSkillModificationLevelConfig;
+    [Speed.Slow]: SlowSkillModificationLevelConfig;
+};
+/**
+ * Returns a common value for a skill modification level depending on the speed.
+ */
+export declare const modifiableBySpeedR: <Fast extends object, Slow extends { [K_ in keyof Fast]: unknown; }, K extends keyof Fast>(key: K, level: {
+    fast: Fast;
+    slow: Slow;
+}) => Reader<{
+    speed: Speed;
+}, (Fast | Slow)[K]>;
+/**
+ * Returns a common value for a skill modification level depending on the speed.
+ */
+export declare const modifiableBySpeedOptionalR: <Fast extends object, Slow extends { [K_ in keyof Fast]: unknown; }, K extends keyof Fast>(key: K, level: {
+    fast?: Fast;
+    slow?: Slow;
+}) => Reader<{
+    speed: Speed;
+}, (Fast | Slow)[K] | undefined>;
+/**
+ * Returns a common value for a skill modification level depending on the speed.
+ */
+export declare const modifyBySpeedR: Reader<{
+    speed: Speed;
+}, <S extends Speed, K extends keyof SpeedMap[S]>(key: K, level: SkillModificationLevel) => SpeedMap[S][K]>;
+/**
+ * Returns the default values wrapped in a reader if the value is nullish, otherwise applies the given function to the value and returns the result.
+ */
+export declare const mapNullableR: <T, U, R>(defaultValue: U, fn: (value: NonNullable<T>) => Reader<U, R>) => (value: T) => Reader<U, R> | Reader<unknown, U>;
+export {};