@optolith/entity-descriptions 0.11.1 → 0.11.2

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

@@ -1,5 +1,5 @@
 import { assertExhaustive } from "@optolith/helpers/typeSafety";
-import { printActivatablePrerequisite, } from "./single/activatable.js";
+import { printActivatablePrerequisite } from "./single/activatable.js";
 import { printAnimistPowerPrerequisite } from "./single/animistPower.js";
 import { printBlessedTraditionPrerequisite } from "./single/blessedTradition.js";
 import { printCommonSuggestedByRCPPrerequisite } from "./single/commonSuggestedByRCP.js";
@@ -27,14 +27,14 @@ import { printTinyActivatablePrerequisite } from "./single/tinyActivatable.js";
 /**
  * Print the translation of a derived characteristic prerequisite group.
  */
-export const printDerivedCharacteristicPrerequisiteGroup = (locale, prerequisite) => {
+export const printDerivedCharacteristicPrerequisiteGroup = (prerequisite) => {
     switch (prerequisite.kind) {
         case "Rule":
-            return printRulePrerequisite(locale, prerequisite.Rule);
+            return printRulePrerequisite(prerequisite.Rule);
         case "BlessedTradition":
-            return printBlessedTraditionPrerequisite(locale, prerequisite.BlessedTradition);
+            return printBlessedTraditionPrerequisite(prerequisite.BlessedTradition);
         case "MagicalTradition":
-            return printMagicalTraditionPrerequisite(locale, prerequisite.MagicalTradition);
+            return printMagicalTraditionPrerequisite(prerequisite.MagicalTradition);
         default:
             return assertExhaustive(prerequisite);
     }
@@ -42,64 +42,61 @@ export const printDerivedCharacteristicPrerequisiteGroup = (locale, prerequisite
 /**
  * Print the translation of a publication prerequisite group.
  */
-export const printPublicationPrerequisiteGroup = (getInstanceById, locale, prerequisite) => 
+export const printPublicationPrerequisiteGroup = (prerequisite) => 
 // switch (prerequisite.tag) {
 //   case "Publication":
 //   default:
 //     return assertExhaustive(prerequisite)
 // }
-printPublicationPrerequisite(getInstanceById, locale, prerequisite.Publication);
+printPublicationPrerequisite(prerequisite.Publication);
 /**
  * Print the translation of a general prerequisite group.
  */
-export const printGeneralPrerequisiteGroup = (getInstanceById, getResolvedSelectOptionById, locale, prerequisite) => {
+export const printGeneralPrerequisiteGroup = (prerequisite) => {
     switch (prerequisite.kind) {
         case "Sex":
-            return printBinarySexPrerequisite(locale.translate, prerequisite.Sex);
+            return printBinarySexPrerequisite(prerequisite.Sex);
         case "Race":
-            return printRacePrerequisite(getInstanceById, locale, prerequisite.Race);
+            return printRacePrerequisite(prerequisite.Race);
         case "Culture":
-            return printCulturePrerequisite(getInstanceById, locale, prerequisite.Culture);
+            return printCulturePrerequisite(prerequisite.Culture);
         case "Pact":
-            return printPactPrerequisite(getInstanceById, locale, prerequisite.Pact);
+            return printPactPrerequisite(prerequisite.Pact);
         case "SocialStatus":
-            return printSocialStatusPrerequisite(getInstanceById, locale, prerequisite.SocialStatus);
+            return printSocialStatusPrerequisite(prerequisite.SocialStatus);
         case "State":
-            return printStatePrerequisite(getInstanceById, locale, prerequisite.State);
+            return printStatePrerequisite(prerequisite.State);
         case "Rule":
-            return printRulePrerequisite(locale, prerequisite.Rule);
+            return printRulePrerequisite(prerequisite.Rule);
         case "PrimaryAttribute":
-            return printPrimaryAttributePrerequisite(locale, prerequisite.PrimaryAttribute);
+            return printPrimaryAttributePrerequisite(prerequisite.PrimaryAttribute);
         case "Activatable":
-            return printActivatablePrerequisite(getInstanceById, getResolvedSelectOptionById, locale, prerequisite.Activatable, false);
+            return printActivatablePrerequisite(prerequisite.Activatable).with(env => ({
+                ...env,
+                displayedInProfession: false,
+            }));
         case "BlessedTradition":
-            return printBlessedTraditionPrerequisite(locale, prerequisite.BlessedTradition);
+            return printBlessedTraditionPrerequisite(prerequisite.BlessedTradition);
         case "MagicalTradition":
-            return printMagicalTraditionPrerequisite(locale, prerequisite.MagicalTradition);
+            return printMagicalTraditionPrerequisite(prerequisite.MagicalTradition);
         case "TinyActivatable":
-            return printTinyActivatablePrerequisite(prerequisite.TinyActivatable).run({
-                getInstanceById,
-                translateMap: locale.translateMap,
-            });
+            return printTinyActivatablePrerequisite(prerequisite.TinyActivatable);
         case "AnySpecialAbilityOfGroup":
-            return printMagicalTraditionPrerequisite(locale, prerequisite.AnySpecialAbilityOfGroup);
+            return printMagicalTraditionPrerequisite(prerequisite.AnySpecialAbilityOfGroup);
         case "Rated":
-            return printRatedPrerequisite(getInstanceById, locale, prerequisite.Rated);
+            return printRatedPrerequisite(prerequisite.Rated);
         case "RatedMinimumNumber":
-            return printRatedMinimumNumberPrerequisite(getInstanceById, locale, prerequisite.RatedMinimumNumber);
+            return printRatedMinimumNumberPrerequisite(prerequisite.RatedMinimumNumber);
         case "RatedSum":
-            return printRatedSumPrerequisite(getInstanceById, locale, prerequisite.RatedSum);
+            return printRatedSumPrerequisite(prerequisite.RatedSum);
         case "Enhancement":
-            return printEnhancementPrerequisite(prerequisite.Enhancement).run({
-                ...locale,
-                getInstanceById,
-            });
+            return printEnhancementPrerequisite(prerequisite.Enhancement);
         case "Text":
-            return printTextPrerequisite(locale, prerequisite.Text);
+            return printTextPrerequisite(prerequisite.Text);
         case "SexualCharacteristic":
-            return printSexualCharacteristicPrerequisite(locale, prerequisite.SexualCharacteristic);
+            return printSexualCharacteristicPrerequisite(prerequisite.SexualCharacteristic);
         case "PersonalityTrait":
-            return printPersonalityTraitPrerequisite(getInstanceById, locale, prerequisite.PersonalityTrait);
+            return printPersonalityTraitPrerequisite(prerequisite.PersonalityTrait);
         default:
             return assertExhaustive(prerequisite);
     }
@@ -107,18 +104,21 @@ export const printGeneralPrerequisiteGroup = (getInstanceById, getResolvedSelect
 /**
  * Print the translation of a profession prerequisite group.
  */
-export const printProfessionPrerequisiteGroup = (getInstanceById, getResolvedSelectOptionById, locale, prerequisite) => {
+export const printProfessionPrerequisiteGroup = (prerequisite) => {
     switch (prerequisite.kind) {
         case "Sex":
-            return printBinarySexPrerequisite(locale.translate, prerequisite.Sex);
+            return printBinarySexPrerequisite(prerequisite.Sex);
         case "Race":
-            return printRacePrerequisite(getInstanceById, locale, prerequisite.Race);
+            return printRacePrerequisite(prerequisite.Race);
         case "Culture":
-            return printCulturePrerequisite(getInstanceById, locale, prerequisite.Culture);
+            return printCulturePrerequisite(prerequisite.Culture);
         case "Activatable":
-            return printActivatablePrerequisite(getInstanceById, getResolvedSelectOptionById, locale, prerequisite.Activatable, true);
+            return printActivatablePrerequisite(prerequisite.Activatable).with(env => ({
+                ...env,
+                displayedInProfession: true,
+            }));
         case "Rated":
-            return printRatedPrerequisite(getInstanceById, locale, prerequisite.Rated);
+            return printRatedPrerequisite(prerequisite.Rated);
         default:
             return assertExhaustive(prerequisite);
     }
@@ -126,12 +126,12 @@ export const printProfessionPrerequisiteGroup = (getInstanceById, getResolvedSel
 /**
  * Print the translation of an advantage/disadvantage prerequisite group.
  */
-export const printAdvantageDisadvantagePrerequisiteGroup = (getInstanceById, getResolvedSelectOptionById, locale, prerequisite, name, type) => {
+export const printAdvantageDisadvantagePrerequisiteGroup = (prerequisite, name, type) => {
     switch (prerequisite.kind) {
         case "CommonSuggestedByRCP":
-            return printCommonSuggestedByRCPPrerequisite(locale, name, type);
+            return printCommonSuggestedByRCPPrerequisite(name, type);
         case "NoOtherAncestorBloodAdvantage":
-            return printNoOtherAncestorBloodAdvantagePrerequisite(locale);
+            return printNoOtherAncestorBloodAdvantagePrerequisite;
         case "Sex":
         case "Race":
         case "Culture":
@@ -152,7 +152,7 @@ export const printAdvantageDisadvantagePrerequisiteGroup = (getInstanceById, get
         case "Text":
         case "SexualCharacteristic":
         case "PersonalityTrait":
-            return printGeneralPrerequisiteGroup(getInstanceById, getResolvedSelectOptionById, locale, prerequisite);
+            return printGeneralPrerequisiteGroup(prerequisite);
         default:
             return assertExhaustive(prerequisite);
     }
@@ -160,12 +160,12 @@ export const printAdvantageDisadvantagePrerequisiteGroup = (getInstanceById, get
 /**
  * Print the translation of an arcane tradition prerequisite group.
  */
-export const printArcaneTraditionPrerequisiteGroup = (getInstanceById, locale, prerequisite) => {
+export const printArcaneTraditionPrerequisiteGroup = (prerequisite) => {
     switch (prerequisite.kind) {
         case "Sex":
-            return printBinarySexPrerequisite(locale.translate, prerequisite.Sex);
+            return printBinarySexPrerequisite(prerequisite.Sex);
         case "Culture":
-            return printCulturePrerequisite(getInstanceById, locale, prerequisite.Culture);
+            return printCulturePrerequisite(prerequisite.Culture);
         default:
             return assertExhaustive(prerequisite);
     }
@@ -173,16 +173,16 @@ export const printArcaneTraditionPrerequisiteGroup = (getInstanceById, locale, p
 /**
  * Print the translation of a personality trait prerequisite group.
  */
-export const printPersonalityTraitPrerequisiteGroup = (getInstanceById, locale, prerequisite) => {
+export const printPersonalityTraitPrerequisiteGroup = (prerequisite) => {
     switch (prerequisite.kind) {
         case "Race":
-            return printRacePrerequisite(getInstanceById, locale, prerequisite.Race);
+            return printRacePrerequisite(prerequisite.Race);
         case "Culture":
-            return printCulturePrerequisite(getInstanceById, locale, prerequisite.Culture);
+            return printCulturePrerequisite(prerequisite.Culture);
         case "PersonalityTrait":
-            return printPersonalityTraitPrerequisite(getInstanceById, locale, prerequisite.PersonalityTrait);
+            return printPersonalityTraitPrerequisite(prerequisite.PersonalityTrait);
         case "Text":
-            return printTextPrerequisite(locale, prerequisite.Text);
+            return printTextPrerequisite(prerequisite.Text);
         default:
             return assertExhaustive(prerequisite);
     }
@@ -190,12 +190,12 @@ export const printPersonalityTraitPrerequisiteGroup = (getInstanceById, locale,
 /**
  * Print the translation of a spellwork prerequisite group.
  */
-export const printSpellworkPrerequisiteGroup = (getInstanceById, locale, prerequisite) => {
+export const printSpellworkPrerequisiteGroup = (prerequisite) => {
     switch (prerequisite.kind) {
         case "Rule":
-            return printRulePrerequisite(locale, prerequisite.Rule);
+            return printRulePrerequisite(prerequisite.Rule);
         case "Rated":
-            return printRatedPrerequisite(getInstanceById, locale, prerequisite.Rated);
+            return printRatedPrerequisite(prerequisite.Rated);
         default:
             return assertExhaustive(prerequisite);
     }
@@ -203,28 +203,31 @@ export const printSpellworkPrerequisiteGroup = (getInstanceById, locale, prerequ
 /**
  * Print the translation of a liturgy prerequisite group.
  */
-export const printLiturgyPrerequisiteGroup = (locale, prerequisite) => 
+export const printLiturgyPrerequisiteGroup = (prerequisite) => 
 // switch (prerequisite.tag) {
 //   case "Rule":
 //   default:
 //     return assertExhaustive(prerequisite)
 // }
-printRulePrerequisite(locale, prerequisite.Rule);
+printRulePrerequisite(prerequisite.Rule);
 /**
  * Print the translation of an influence prerequisite group.
  */
-export const printInfluencePrerequisiteGroup = (getInstanceById, getResolvedSelectOptionById, getChildInstancesForInstanceId, locale, prerequisite) => {
+export const printInfluencePrerequisiteGroup = (prerequisite) => {
     switch (prerequisite.kind) {
         case "Influence":
-            return printInfluencePrerequisite(getInstanceById, locale, prerequisite.Influence);
+            return printInfluencePrerequisite(prerequisite.Influence);
         case "Race":
-            return printRacePrerequisite(getInstanceById, locale, prerequisite.Race);
+            return printRacePrerequisite(prerequisite.Race);
         case "Profession":
-            return printProfessionPrerequisite(getChildInstancesForInstanceId, locale, prerequisite.Profession);
+            return printProfessionPrerequisite(prerequisite.Profession);
         case "Activatable":
-            return printActivatablePrerequisite(getInstanceById, getResolvedSelectOptionById, locale, prerequisite.Activatable, false);
+            return printActivatablePrerequisite(prerequisite.Activatable).with(env => ({
+                ...env,
+                displayedInProfession: false,
+            }));
         case "Text":
-            return printTextPrerequisite(locale, prerequisite.Text);
+            return printTextPrerequisite(prerequisite.Text);
         default:
             return assertExhaustive(prerequisite);
     }
@@ -232,14 +235,17 @@ export const printInfluencePrerequisiteGroup = (getInstanceById, getResolvedSele
 /**
  * Print the translation of a language prerequisite group.
  */
-export const printLanguagePrerequisiteGroup = (getInstanceById, getResolvedSelectOptionById, locale, prerequisite) => {
+export const printLanguagePrerequisiteGroup = (prerequisite) => {
     switch (prerequisite.kind) {
         case "Race":
-            return printRacePrerequisite(getInstanceById, locale, prerequisite.Race);
+            return printRacePrerequisite(prerequisite.Race);
         case "Activatable":
-            return printActivatablePrerequisite(getInstanceById, getResolvedSelectOptionById, locale, prerequisite.Activatable, false);
+            return printActivatablePrerequisite(prerequisite.Activatable).with(env => ({
+                ...env,
+                displayedInProfession: false,
+            }));
         case "Text":
-            return printTextPrerequisite(locale, prerequisite.Text);
+            return printTextPrerequisite(prerequisite.Text);
         default:
             return assertExhaustive(prerequisite);
     }
@@ -247,22 +253,25 @@ export const printLanguagePrerequisiteGroup = (getInstanceById, getResolvedSelec
 /**
  * Print the translation of an animist power prerequisite group.
  */
-export const printAnimistPowerPrerequisiteGroup = (getInstanceById, locale, prerequisite) => 
+export const printAnimistPowerPrerequisiteGroup = (prerequisite) => 
 // switch (prerequisite.tag) {
 //   case "AnimistPower":
 //   default:
 //     return assertExhaustive(prerequisite)
 // }
-printAnimistPowerPrerequisite(getInstanceById, locale, prerequisite.AnimistPower);
+printAnimistPowerPrerequisite(prerequisite.AnimistPower);
 /**
  * Print the translation of a geode ritual prerequisite group.
  */
-export const printGeodeRitualPrerequisiteGroup = (getInstanceById, getResolvedSelectOptionById, locale, prerequisite) => {
+export const printGeodeRitualPrerequisiteGroup = (prerequisite) => {
     switch (prerequisite.kind) {
         case "Activatable":
-            return printActivatablePrerequisite(getInstanceById, getResolvedSelectOptionById, locale, prerequisite.Activatable, false);
+            return printActivatablePrerequisite(prerequisite.Activatable).with(env => ({
+                ...env,
+                displayedInProfession: false,
+            }));
         case "Influence":
-            return printInfluencePrerequisite(getInstanceById, locale, prerequisite.Influence);
+            return printInfluencePrerequisite(prerequisite.Influence);
         default:
             return assertExhaustive(prerequisite);
     }
@@ -270,16 +279,15 @@ export const printGeodeRitualPrerequisiteGroup = (getInstanceById, getResolvedSe
 /**
  * Print the translation of an enhancement prerequisite group.
  */
-export const printEnhancementPrerequisiteGroup = (getInstanceById, locale, prerequisite) => {
+export const printEnhancementPrerequisiteGroup = (prerequisite) => {
     switch (prerequisite.kind) {
         case "Rated":
-            return printRatedPrerequisite(getInstanceById, locale, prerequisite.Rated);
+            return printRatedPrerequisite(prerequisite.Rated);
         case "Enhancement":
-            return printEnhancementPrerequisite(prerequisite.Enhancement).run({
-                ...locale,
-                getInstanceById,
+            return printEnhancementPrerequisite(prerequisite.Enhancement).with(env => ({
+                ...env,
                 hideParent: true,
-            });
+            }));
         default:
             return assertExhaustive(prerequisite);
     }
@@ -287,14 +295,14 @@ export const printEnhancementPrerequisiteGroup = (getInstanceById, locale, prere
 /**
  * Print the translation of a precondition group.
  */
-export const printPreconditionGroup = (getInstanceById, locale, prerequisite) => {
+export const printPreconditionGroup = (prerequisite) => {
     switch (prerequisite.kind) {
         case "Publication":
-            return printPublicationPrerequisite(getInstanceById, locale, prerequisite.Publication);
+            return printPublicationPrerequisite(prerequisite.Publication);
         case "Rule":
-            return printRulePrerequisite(locale, prerequisite.Rule);
+            return printRulePrerequisite(prerequisite.Rule);
         case "SexualCharacteristic":
-            return printSexualCharacteristicPrerequisite(locale, prerequisite.SexualCharacteristic);
+            return printSexualCharacteristicPrerequisite(prerequisite.SexualCharacteristic);
         default:
             return assertExhaustive(prerequisite);
     }

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

@@ -1,8 +1,7 @@
 import type { ResolvedSelectOption, ResolvedSelectOptionIdentifier } from "@optolith/database-schema/cache";
 import type { ActivatableIdentifier, ActivatablePrerequisite, RequirableSelectOptionIdentifier } from "@optolith/database-schema/gen";
-import type { GetInstanceById } from "../../../../helpers/getTypes.js";
-import type { LocaleEnvironment } from "../../../../helpers/locale.js";
-import type { Translate } from "../../../../helpers/translate.js";
+import type { StdReader } from "../../../../env.js";
+import { type ActivatableNameComponents } from "../../activatableNameChunks.js";
 import type { PrerequisitePart } from "../part.js";
 /**
  * Gets a resolved select option by its identifier.
@@ -11,8 +10,8 @@ export type GetResolvedSelectOptionById = (id: ActivatableIdentifier, selectOpti
 /**
  * Get the name components of an activatable.
  */
-export declare const printActivatableName: (getInstanceById: GetInstanceById<ActivatableIdentifier["kind"] | "Aspect">, translate: Translate, id: ActivatableIdentifier, options: RequirableSelectOptionIdentifier[] | undefined, level: number | undefined, getResolvedSelectOptionById: GetResolvedSelectOptionById, displayedInProfession: boolean) => import("../../activatableNameChunks.js").ActivatableNameComponents | undefined;
+export declare const printActivatableName: (id: ActivatableIdentifier, options: RequirableSelectOptionIdentifier[] | undefined, level: number | undefined) => StdReader<ActivatableNameComponents | undefined, "t" | "rso" | "ibi" | "dip", ActivatableIdentifier["kind"] | "Aspect">;
 /**
  * Get the translation of a blessed tradition prerequisite.
  */
-export declare const printActivatablePrerequisite: (getInstanceById: GetInstanceById<ActivatableIdentifier["kind"] | "Aspect">, getResolvedSelectOptionById: GetResolvedSelectOptionById, locale: Pick<LocaleEnvironment, "translate" | "translateMap">, prerequisite: ActivatablePrerequisite, displayedInProfession: boolean) => PrerequisitePart | undefined;
+export declare const printActivatablePrerequisite: (prerequisite: ActivatablePrerequisite) => StdReader<PrerequisitePart | undefined, "t" | "tm" | "rso" | "ibi" | "dip", ActivatableIdentifier["kind"] | "Aspect">;

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

@@ -1,40 +1,32 @@
+import { Reader } from "@elyukai/utils/reader";
 import { getNameComponents } from "../../activatableNameChunks.js";
+import { getInstanceByIdR, translateR } from "../../reader.js";
+import { MISSING_VALUE } from "../../unknown.js";
 import { printDisplayOption } from "../displayOption.js";
 /**
  * Get the name components of an activatable.
  */
-export const printActivatableName = (getInstanceById, translate, id, options, level, getResolvedSelectOptionById, displayedInProfession) => {
-    const entry = getInstanceById(id);
-    if (entry === undefined) {
-        return undefined;
-    }
-    return getNameComponents(translate, id, options, level, entry.nameBuilderRules, entry.translations, t => t.name, getResolvedSelectOptionById, displayedInProfession);
-};
+export const printActivatableName = (id, options, level) => getInstanceByIdR(id).thenW((entry) => entry === undefined
+    ? Reader.of(undefined)
+    : Reader.asks((env) => getNameComponents(env.translate, id, options, level, entry.nameBuilderRules, entry.translations, t => t.name, env.getResolvedSelectOptionById, env.displayedInProfession)));
 /**
  * Get the translation of a blessed tradition prerequisite.
  */
-export const printActivatablePrerequisite = (getInstanceById, getResolvedSelectOptionById, locale, prerequisite, displayedInProfession) => {
-    if (prerequisite.display_option !== undefined) {
-        return printDisplayOption(locale.translateMap, prerequisite.display_option);
-    }
-    const nameComponents = printActivatableName(getInstanceById, locale.translate, prerequisite.id, prerequisite.options, prerequisite.level, getResolvedSelectOptionById, displayedInProfession);
-    if (nameComponents === undefined) {
-        return undefined;
-    }
-    return {
-        label: `${prerequisite.id.kind === "Advantage"
+export const printActivatablePrerequisite = (prerequisite) => prerequisite.display_option !== undefined
+    ? printDisplayOption(prerequisite.display_option)
+    : printActivatableName(prerequisite.id, prerequisite.options, prerequisite.level).then(nameComponents => (prerequisite.id.kind === "Advantage"
+        ? prerequisite.active
+            ? translateR("advantage")
+            : translateR("no advantage")
+        : prerequisite.id.kind === "Disadvantage"
             ? prerequisite.active
-                ? locale.translate("advantage")
-                : locale.translate("no advantage")
-            : prerequisite.id.kind === "Disadvantage"
-                ? prerequisite.active
-                    ? locale.translate("disadvantage")
-                    : locale.translate("no disadvantage")
-                : prerequisite.active
-                    ? locale.translate("special ability")
-                    : locale.translate("no special ability")} `,
-        value: nameComponents,
+                ? translateR("disadvantage")
+                : translateR("no disadvantage")
+            : prerequisite.active
+                ? translateR("special ability")
+                : translateR("no special ability")).map((label) => ({
+        label: `${label} `,
+        value: nameComponents ?? MISSING_VALUE,
         sentenceType: undefined,
         isMeta: false,
-    };
-};
+    })));

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

@@ -1,8 +1,7 @@
 import type { AnimistPowerPrerequisite } from "@optolith/database-schema/gen";
-import { type GetInstanceById } from "../../../../helpers/getTypes.js";
-import type { LocaleEnvironment } from "../../../../helpers/locale.js";
+import type { StdReader } from "../../../../env.js";
 import type { PrerequisitePart } from "../part.js";
 /**
  * Get the translation of a culture prerequisite.
  */
-export declare const printAnimistPowerPrerequisite: (getInstanceById: GetInstanceById<"AnimistPower">, locale: LocaleEnvironment, prerequisite: AnimistPowerPrerequisite) => PrerequisitePart | undefined;
+export declare const printAnimistPowerPrerequisite: (prerequisite: AnimistPowerPrerequisite) => StdReader<PrerequisitePart | undefined, "tm" | "ibi", "AnimistPower">;

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

@@ -1,17 +1,15 @@
 import { isNotNullish } from "@optolith/helpers/nullable";
 import { romanize } from "@optolith/helpers/roman";
+import { attributedNameR } from "../../reader.js";
 import { printDisplayOption } from "../displayOption.js";
 /**
  * Get the translation of a culture prerequisite.
  */
-export const printAnimistPowerPrerequisite = (getInstanceById, locale, prerequisite) => {
-    if (prerequisite.display_option !== undefined) {
-        return printDisplayOption(locale.translateMap, prerequisite.display_option);
-    }
-    const animistPower = getInstanceById("AnimistPower", prerequisite.id);
-    return {
+export const printAnimistPowerPrerequisite = (prerequisite) => prerequisite.display_option !== undefined
+    ? printDisplayOption(prerequisite.display_option)
+    : attributedNameR("prerequisite", "AnimistPower", prerequisite.id).map(name => ({
         value: [
-            locale.translateMap(animistPower?.translations)?.name ?? "MISSING_VALUE",
+            name ?? "MISSING_VALUE",
             prerequisite.level === undefined ? undefined : romanize(prerequisite.level),
             prerequisite.value.toFixed(),
         ]
@@ -19,5 +17,4 @@ export const printAnimistPowerPrerequisite = (getInstanceById, locale, prerequis
             .join(" "),
         sentenceType: undefined,
         isMeta: false,
-    };
-};
+    }));

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

@@ -1,5 +1,5 @@
 import type { AnySpecialAbilityOfGroupPrerequisite } from "@optolith/database-schema/gen";
-import { type StdReader } from "../../reader.js";
+import type { StdReader } from "../../../../env.js";
 import type { PrerequisitePart } from "../part.js";
 /**
  * Get the translation of a tiny activatable prerequisite.

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

@@ -1,17 +1,14 @@
 import { translateR } from "../../reader.js";
-import { printDisplayOptionR } from "../displayOption.js";
+import { printDisplayOption } from "../displayOption.js";
 /**
  * Get the translation of a tiny activatable prerequisite.
  */
-export const printAnySpecialAbilityOfGroupPrerequisite = (prerequisite) => {
-    if (prerequisite.display_option !== undefined) {
-        return printDisplayOptionR(prerequisite.display_option);
-    }
-    return translateR(".input {$entity :string} {{a special ability}}", {
+export const printAnySpecialAbilityOfGroupPrerequisite = (prerequisite) => prerequisite.display_option !== undefined
+    ? printDisplayOption(prerequisite.display_option)
+    : translateR(".input {$entity :string} {{a special ability}}", {
         entity: prerequisite.group.kind,
     }).map(name => ({
         value: name,
         sentenceType: undefined,
         isMeta: false,
     }));
-};

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

@@ -1,7 +1,7 @@
 import type { BlessedTraditionPrerequisite } from "@optolith/database-schema/gen";
-import type { LocaleEnvironment } from "../../../../helpers/locale.js";
+import type { StdReader } from "../../../../env.js";
 import type { PrerequisitePart } from "../part.js";
 /**
  * Get the translation of a blessed tradition prerequisite.
  */
-export declare const printBlessedTraditionPrerequisite: (locale: LocaleEnvironment, prerequisite: BlessedTraditionPrerequisite) => PrerequisitePart | undefined;
+export declare const printBlessedTraditionPrerequisite: (prerequisite: BlessedTraditionPrerequisite) => StdReader<PrerequisitePart | undefined, "t" | "tm">;

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

@@ -1,17 +1,18 @@
 import { assertExhaustive } from "@optolith/helpers/typeSafety";
+import { translateR } from "../../reader.js";
 import { printDisplayOption } from "../displayOption.js";
-const printValue = (locale, restriction) => {
+const printValue = (restriction) => {
     switch (restriction?.kind) {
         case "Church":
-            return locale.translate("Tradition ({$tradition})", {
-                tradition: locale.translate("Church"),
-            });
+            return translateR("Church").then(tradition => translateR("Tradition ({$tradition})", {
+                tradition,
+            }));
         case "Shamanistic":
-            return locale.translate("Tradition ({$tradition})", {
-                tradition: locale.translate("Shaman"),
-            });
+            return translateR("Shaman").then(tradition => translateR("Tradition ({$tradition})", {
+                tradition,
+            }));
         case undefined:
-            return locale.translate("Tradition");
+            return translateR("Tradition");
         default:
             return assertExhaustive(restriction);
     }
@@ -19,14 +20,11 @@ const printValue = (locale, restriction) => {
 /**
  * Get the translation of a blessed tradition prerequisite.
  */
-export const printBlessedTraditionPrerequisite = (locale, prerequisite) => {
-    if (prerequisite.display_option !== undefined) {
-        return printDisplayOption(locale.translateMap, prerequisite.display_option);
-    }
-    return {
-        label: `${locale.translate("special ability")} `,
-        value: printValue(locale, prerequisite.restriction),
+export const printBlessedTraditionPrerequisite = (prerequisite) => prerequisite.display_option !== undefined
+    ? printDisplayOption(prerequisite.display_option)
+    : translateR("special ability").then(label => printValue(prerequisite.restriction).map((value) => ({
+        label: `${label} `,
+        value,
         sentenceType: undefined,
         isMeta: false,
-    };
-};
+    })));

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

@@ -1,6 +1,6 @@
-import type { LocaleEnvironment } from "../../../../helpers/locale.js";
+import type { StdReader } from "../../../../env.js";
 import type { PrerequisitePart } from "../part.js";
 /**
  * Get the translation of a culture prerequisite.
  */
-export declare const printCommonSuggestedByRCPPrerequisite: (locale: LocaleEnvironment, name: string, type: "Advantage" | "Disadvantage") => PrerequisitePart | undefined;
+export declare const printCommonSuggestedByRCPPrerequisite: (name: string, type: "Advantage" | "Disadvantage") => StdReader<PrerequisitePart | undefined, "t">;

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

@@ -1,10 +1,11 @@
 import { assertExhaustive } from "@optolith/helpers/typeSafety";
-const printType = (locale, type) => {
+import { translateR } from "../../reader.js";
+const printType = (type) => {
     switch (type) {
         case "Advantage":
-            return locale.translate("advantage");
+            return translateR("advantage");
         case "Disadvantage":
-            return locale.translate("disadvantage");
+            return translateR("disadvantage");
         default:
             return assertExhaustive(type);
     }
@@ -12,8 +13,10 @@ const printType = (locale, type) => {
 /**
  * Get the translation of a culture prerequisite.
  */
-export const printCommonSuggestedByRCPPrerequisite = (locale, name, type) => ({
-    value: locale.translate("Race, culture, or profession must have {$entry} as an automatic or suggested {$itemOfCategory}", { entry: name, itemOfCategory: printType(locale, type) }),
+export const printCommonSuggestedByRCPPrerequisite = (name, type) => printType(type)
+    .then(itemOfCategory => translateR("Race, culture, or profession must have {$entry} as an automatic or suggested {$itemOfCategory}", { entry: name, itemOfCategory }))
+    .map((value) => ({
+    value,
     sentenceType: undefined,
     isMeta: false,
-});
+}));

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

@@ -1,8 +1,7 @@
 import type { CulturePrerequisite } from "@optolith/database-schema/gen";
-import type { GetInstanceById } from "../../../../helpers/getTypes.js";
-import type { LocaleEnvironment } from "../../../../helpers/locale.js";
+import type { StdReader } from "../../../../env.js";
 import type { PrerequisitePart } from "../part.js";
 /**
  * Get the translation of a culture prerequisite.
  */
-export declare const printCulturePrerequisite: (getInstanceById: GetInstanceById<"Culture">, locale: Pick<LocaleEnvironment, "translate" | "translateMap">, prerequisite: CulturePrerequisite) => PrerequisitePart | undefined;
+export declare const printCulturePrerequisite: (prerequisite: CulturePrerequisite) => StdReader<PrerequisitePart | undefined, "t" | "tm" | "ibi", "Culture">;