@optolith/entity-descriptions 0.11.1 → 0.12.0

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

@@ -1,63 +1,87 @@
 import { isNotEmpty } from "@elyukai/utils/array/nonEmpty";
 import { on } from "@elyukai/utils/function";
 import { mapNullable } from "@elyukai/utils/nullable";
+import { Reader } from "@elyukai/utils/reader";
 import { numAsc } from "@optolith/helpers/compare";
 import { isNotNullish } from "@optolith/helpers/nullable";
 import { romanize } from "@optolith/helpers/roman";
 import { assertExhaustive } from "@optolith/helpers/typeSafety";
 import { renderActivatableNameComponents, renderActivatableNameComponentsCombinedIfPossible, } from "../activatableNameChunks.js";
+import { localeJoinR, translateR } from "../reader.js";
 import { MISSING_VALUE } from "../unknown.js";
 import { printDisplayOption } from "./displayOption.js";
 import { hasPartValueObject, joinPrerequisiteParts } from "./part.js";
 import { printAdvantageDisadvantagePrerequisiteGroup, printAnimistPowerPrerequisiteGroup, printArcaneTraditionPrerequisiteGroup, printDerivedCharacteristicPrerequisiteGroup, printEnhancementPrerequisiteGroup, printGeneralPrerequisiteGroup, printGeodeRitualPrerequisiteGroup, printInfluencePrerequisiteGroup, printLanguagePrerequisiteGroup, printLiturgyPrerequisiteGroup, printPersonalityTraitPrerequisiteGroup, printProfessionPrerequisiteGroup, printPublicationPrerequisiteGroup, printSpellworkPrerequisiteGroup, } from "./prerequisiteGroups.js";
-const printPrerequisiteGroup = (translateMap, group) => ({
-    value: translateMap(group.translations)?.text ?? MISSING_VALUE,
+const printPrerequisiteGroup = (group) => Reader.asks(env => ({
+    value: env.translateMap(group.translations)?.text ?? MISSING_VALUE,
     sentenceType: undefined,
     isMeta: false,
-});
-const printPrerequisitesDisjunction = (getPrerequisiteTranslation, locale, disjunction) => {
+}));
+const printPrerequisitesDisjunction = (getPrerequisiteTranslation, disjunction) => {
     if (disjunction.display_option !== undefined) {
-        return printDisplayOption(locale.translateMap, disjunction.display_option);
+        return printDisplayOption(disjunction.display_option);
     }
-    const { list: disjunctionList } = disjunction;
-    const [first, ...other] = disjunctionList.map(getPrerequisiteTranslation).filter(isNotNullish);
-    if (first === undefined) {
-        return undefined;
-    }
-    if (disjunctionList.length < 2 ||
-        (isNotEmpty(disjunctionList) &&
-            disjunctionList.slice(1).every(part => part.kind === disjunctionList[0].kind))) {
-        return {
-            label: first.label,
-            value: hasPartValueObject(first) && other.every(hasPartValueObject)
-                ? renderActivatableNameComponentsCombinedIfPossible(locale.translateMap, [first.value, ...other.map(part => part.value)], true, list => locale.join(list, "disjunction"))
-                : locale.join([first, ...other].map(part => typeof part.value === "string"
+    const disjunctionList = disjunction.list;
+    return Reader.traverse(disjunctionList, getPrerequisiteTranslation)
+        .map(list => list.filter(isNotNullish))
+        .thenW(([first, ...other]) => {
+        if (first === undefined) {
+            return Reader.of(undefined);
+        }
+        if (disjunctionList.length < 2 ||
+            (isNotEmpty(disjunctionList) &&
+                disjunctionList.slice(1).every(part => part.kind === disjunctionList[0].kind))) {
+            return (hasPartValueObject(first) && other.every(hasPartValueObject)
+                ? Reader.asks((env) => renderActivatableNameComponentsCombinedIfPossible(env.translate, env.translateMap, [first.value, ...other.map(part => part.value)], true, list => env.localeJoin(list.toSorted(env.localeCompare), "disjunction")))
+                : Reader.traverse([first, ...other], part => Reader.asks((env) => typeof part.value === "string"
                     ? part.value
-                    : renderActivatableNameComponents(locale.translateMap, part.value, true)), "disjunction"),
-            sentenceType: undefined,
-            isMeta: false,
-        };
-    }
-    return {
-        value: locale.join([first, ...other].map(part => (part.label ?? "") +
+                    : renderActivatableNameComponents(env.translateMap, part.value, true))).thenW(list => localeJoinR(list, "disjunction"))).map(value => ({
+                label: first.label,
+                value,
+                sentenceType: undefined,
+                isMeta: false,
+            }));
+        }
+        return Reader.traverse([first, ...other], part => Reader.asks((env) => (part.label ?? "") +
             (typeof part.value === "string"
                 ? part.value
-                : renderActivatableNameComponents(locale.translateMap, part.value, true))), "disjunction"),
-        sentenceType: undefined,
-        isMeta: false,
-    };
+                : renderActivatableNameComponents(env.translateMap, part.value, true))))
+            .thenW(list => localeJoinR(list, "disjunction"))
+            .map(value => ({
+            value,
+            sentenceType: undefined,
+            isMeta: false,
+        }));
+    });
 };
 /**
  * Print prerequisites element as a string.
  */
-const printPrerequisitesElement = (printPrerequisite, locale, element) => {
+const printPrerequisitesElement = (printPrerequisite, element) => {
     switch (element.kind) {
         case "Single":
             return printPrerequisite(element.Single);
         case "Disjunction":
-            return printPrerequisitesDisjunction(printPrerequisite, locale, element.Disjunction);
+            return printPrerequisitesDisjunction(printPrerequisite, element.Disjunction);
         case "Group":
-            return printPrerequisiteGroup(locale.translateMap, element.Group);
+            return printPrerequisiteGroup(element.Group);
+        default:
+            return assertExhaustive(element);
+    }
+};
+/**
+ * Print plain prerequisites as a string.
+ */
+const printPlainPrerequisites = (printPrerequisite, prerequisites) => Reader.traverse(prerequisites, element => printPrerequisitesElement(printPrerequisite, element).map(nullablePart => mapNullable(nullablePart, part => ({
+    type: element.kind === "Single" ? element.Single.kind : element.kind,
+    part,
+})))).thenW(list => joinPrerequisiteParts(list.filter(isNotNullish)));
+const printPrerequisiteDiff = (printPrerequisite, map, element) => {
+    switch (element.kind) {
+        case "Add":
+            return printPrerequisite(element.Add).map(part => map(element.Add, part));
+        case "Remove":
+            return printPrerequisite(element.Remove).map(part => map(element.Remove, part === undefined ? undefined : { ...part, isRemoved: true }));
         default:
             return assertExhaustive(element);
     }
@@ -65,20 +89,18 @@ const printPrerequisitesElement = (printPrerequisite, locale, element) => {
 /**
  * Print plain prerequisites as a string.
  */
-const printPlainPrerequisites = (printPrerequisite, locale, prerequisites) => joinPrerequisiteParts(locale.translate, locale.translateMap, locale.compare, prerequisites
-    .map(element => mapNullable(printPrerequisitesElement(printPrerequisite, locale, element), part => ({
+const printPlainDiffPrerequisites = (printPrerequisite, prerequisites) => Reader.traverse(prerequisites, diffElement => printPrerequisiteDiff(element => printPrerequisitesElement(printPrerequisite, element), (element, nullablePart) => mapNullable(nullablePart, part => ({
     type: element.kind === "Single" ? element.Single.kind : element.kind,
     part,
-})))
-    .filter(isNotNullish));
+})), diffElement)).thenW(list => joinPrerequisiteParts(list.filter(isNotNullish)));
 /**
  * Print prerequisite for level as a string.
  */
-const printPrerequisiteForLevel = (printPrerequisite, locale, value) => printPrerequisitesElement(printPrerequisite, locale, value.prerequisite);
+const printPrerequisiteForLevel = (printPrerequisite, value) => printPrerequisitesElement(printPrerequisite, value.prerequisite);
 /**
  * Print prerequisites for levels as a string.
  */
-const printPrerequisitesForLevels = (printPrerequisite, locale, value, printPreviousLevelPrerequisites, trailingText) => {
+const printPrerequisitesForLevels = (printPrerequisite, value, printPreviousLevelPrerequisites, trailingText) => {
     const previousLevelPrerequisites = printPreviousLevelPrerequisites === undefined
         ? []
         : Array.from({ length: printPreviousLevelPrerequisites.levels - 1 }, (_, i) => ({
@@ -102,21 +124,19 @@ const printPrerequisitesForLevels = (printPrerequisite, locale, value, printPrev
         ...(hasBasePrerequisites
             ? []
             : [
-                `${locale.translate("Level {$level}", {
+                translateR("Level {$level}", {
                     level: romanize(1),
-                })}: ${locale.translate("none")}`,
+                }).then(levelLabel => translateR("none").map(levelValue => `${levelLabel}: ${levelValue}`)),
             ]),
         ...sortedByLevel.map(([levelNumber, prerequisites]) => {
-            const prerequisitesString = joinPrerequisiteParts(locale.translate, locale.translateMap, locale.compare, [
-                ...prerequisites
-                    .map(element => mapNullable(printPrerequisiteForLevel(printPrerequisite, locale, element), part => ({
+            const prerequisitesString = Reader.sequence([
+                Reader.traverse(prerequisites, element => printPrerequisiteForLevel(printPrerequisite, element).map(nullablePart => mapNullable(nullablePart, part => ({
                     type: element.prerequisite.kind === "Single"
                         ? element.prerequisite.Single.kind
                         : element.prerequisite.kind,
                     part,
-                })))
-                    .filter(isNotNullish),
-                ...(levelNumber === 1 && trailingText !== undefined
+                })))).map(list => list.filter(isNotNullish)),
+                Reader.of(levelNumber === 1 && trailingText !== undefined
                     ? [
                         {
                             type: "trailing",
@@ -124,32 +144,32 @@ const printPrerequisitesForLevels = (printPrerequisite, locale, value, printPrev
                         },
                     ]
                     : []),
-            ]);
+            ]).then(list => joinPrerequisiteParts(list.flat()));
             return hasOnlyBasePrerequisites
                 ? prerequisitesString
-                : `${locale.translate("Level {$level}", {
+                : prerequisitesString.then(string => translateR("Level {$level}", {
                     level: romanize(levelNumber),
-                })}: ${prerequisitesString}`;
+                }).map(levelLabel => `${levelLabel}: ${string}`));
         }),
     ];
-    return printedParts.join("; ");
+    return Reader.sequence(printedParts).map(parts => parts.join("; "));
 };
 /**
  * Print derived characteristic prerequisites as a string.
  */
-export const printDerivedCharacteristicPrerequisites = (locale, value) => printPlainPrerequisites(prerequisite => printDerivedCharacteristicPrerequisiteGroup(locale, prerequisite), locale, value);
+export const printDerivedCharacteristicPrerequisites = (value) => printPlainPrerequisites(printDerivedCharacteristicPrerequisiteGroup, value);
 /**
  * Print publication prerequisites as a string.
  */
-export const printPublicationPrerequisites = (getInstanceById, locale, value) => printPlainPrerequisites(prerequisite => printPublicationPrerequisiteGroup(getInstanceById, locale, prerequisite), locale, value);
+export const printPublicationPrerequisites = (value) => printPlainPrerequisites(printPublicationPrerequisiteGroup, value);
 /**
  * Print plain general prerequisites as a string.
  */
-export const printPlainGeneralPrerequisites = (getInstanceById, getResolvedSelectOptionById, locale, value) => printPlainPrerequisites(prerequisite => printGeneralPrerequisiteGroup(getInstanceById, getResolvedSelectOptionById, locale, prerequisite), locale, value);
+export const printPlainGeneralPrerequisites = (value) => printPlainPrerequisites(printGeneralPrerequisiteGroup, value);
 /**
  * Print general prerequisites as a string.
  */
-export const printGeneralPrerequisites = (getInstanceById, getResolvedSelectOptionById, locale, value, printPreviousLevelPrerequisites, trailingText) => printPrerequisitesForLevels(prerequisite => printGeneralPrerequisiteGroup(getInstanceById, getResolvedSelectOptionById, locale, prerequisite), locale, value, printPreviousLevelPrerequisites === undefined
+export const printGeneralPrerequisites = (value, printPreviousLevelPrerequisites, trailingText) => printPrerequisitesForLevels(printGeneralPrerequisiteGroup, value, printPreviousLevelPrerequisites === undefined
     ? undefined
     : {
         levels: printPreviousLevelPrerequisites.levels,
@@ -165,44 +185,48 @@ export const printGeneralPrerequisites = (getInstanceById, getResolvedSelectOpti
 /**
  * Print profession prerequisites as a string.
  */
-export const printProfessionPrerequisites = (getInstanceById, getResolvedSelectOptionById, locale, value) => printPlainPrerequisites(prerequisite => printProfessionPrerequisiteGroup(getInstanceById, getResolvedSelectOptionById, locale, prerequisite), locale, value);
+export const printProfessionPrerequisites = (value) => printPlainPrerequisites(printProfessionPrerequisiteGroup, value);
+/**
+ * Print profession prerequisites as a string.
+ */
+export const printProfessionVariantPrerequisites = (value) => printPlainDiffPrerequisites(printProfessionPrerequisiteGroup, value);
 /**
  * Print advantage disadvantage prerequisites as a string.
  */
-export const printAdvantageDisadvantagePrerequisites = (getInstanceById, getResolvedSelectOptionById, locale, value, name, type) => printPrerequisitesForLevels(prerequisite => printAdvantageDisadvantagePrerequisiteGroup(getInstanceById, getResolvedSelectOptionById, locale, prerequisite, name, type), locale, value);
+export const printAdvantageDisadvantagePrerequisites = (value, name, type) => printPrerequisitesForLevels(prerequisite => printAdvantageDisadvantagePrerequisiteGroup(prerequisite, name, type), value);
 /**
  * Print arcane tradition prerequisites as a string.
  */
-export const printArcaneTraditionPrerequisites = (getInstanceById, locale, value) => printPlainPrerequisites(prerequisite => printArcaneTraditionPrerequisiteGroup(getInstanceById, locale, prerequisite), locale, value);
+export const printArcaneTraditionPrerequisites = (value) => printPlainPrerequisites(printArcaneTraditionPrerequisiteGroup, value);
 /**
  * Print personality trait prerequisites as a string.
  */
-export const printPersonalityTraitPrerequisites = (getInstanceById, locale, value) => printPlainPrerequisites(prerequisite => printPersonalityTraitPrerequisiteGroup(getInstanceById, locale, prerequisite), locale, value);
+export const printPersonalityTraitPrerequisites = (value) => printPlainPrerequisites(printPersonalityTraitPrerequisiteGroup, value);
 /**
  * Print spellwork prerequisites as a string.
  */
-export const printSpellworkPrerequisites = (getInstanceById, locale, value) => printPlainPrerequisites(prerequisite => printSpellworkPrerequisiteGroup(getInstanceById, locale, prerequisite), locale, value);
+export const printSpellworkPrerequisites = (value) => printPlainPrerequisites(printSpellworkPrerequisiteGroup, value);
 /**
  * Print liturgy prerequisites as a string.
  */
-export const printLiturgyPrerequisites = (locale, value) => printPlainPrerequisites(prerequisite => printLiturgyPrerequisiteGroup(locale, prerequisite), locale, value);
+export const printLiturgyPrerequisites = (value) => printPlainPrerequisites(printLiturgyPrerequisiteGroup, value);
 /**
  * Print influence prerequisites as a string.
  */
-export const printInfluencePrerequisites = (getInstanceById, getResolvedSelectOptionById, getChildInstancesForInstanceId, locale, value) => printPlainPrerequisites(prerequisite => printInfluencePrerequisiteGroup(getInstanceById, getResolvedSelectOptionById, getChildInstancesForInstanceId, locale, prerequisite), locale, value);
+export const printInfluencePrerequisites = (value) => printPlainPrerequisites(printInfluencePrerequisiteGroup, value);
 /**
  * Print language prerequisites as a string.
  */
-export const printLanguagePrerequisites = (getInstanceById, getResolvedSelectOptionById, locale, value) => printPrerequisitesForLevels(prerequisite => printLanguagePrerequisiteGroup(getInstanceById, getResolvedSelectOptionById, locale, prerequisite), locale, value);
+export const printLanguagePrerequisites = (value) => printPrerequisitesForLevels(printLanguagePrerequisiteGroup, value);
 /**
  * Print animist power prerequisites as a string.
  */
-export const printAnimistPowerPrerequisites = (getInstanceById, locale, value) => printPlainPrerequisites(prerequisite => printAnimistPowerPrerequisiteGroup(getInstanceById, locale, prerequisite), locale, value);
+export const printAnimistPowerPrerequisites = (value) => printPlainPrerequisites(printAnimistPowerPrerequisiteGroup, value);
 /**
  * Print geode ritual prerequisites as a string.
  */
-export const printGeodeRitualPrerequisites = (getInstanceById, getResolvedSelectOptionById, locale, value) => printPlainPrerequisites(prerequisite => printGeodeRitualPrerequisiteGroup(getInstanceById, getResolvedSelectOptionById, locale, prerequisite), locale, value);
+export const printGeodeRitualPrerequisites = (value) => printPlainPrerequisites(printGeodeRitualPrerequisiteGroup, value);
 /**
  * Print enhancement prerequisites as a string.
  */
-export const printEnhancementPrerequisites = (getInstanceById, locale, value) => printPlainPrerequisites(prerequisite => printEnhancementPrerequisiteGroup(getInstanceById, locale, prerequisite), locale, value);
+export const printEnhancementPrerequisites = (value) => printPlainPrerequisites(printEnhancementPrerequisiteGroup, value);

package/lib/entities/partial/prerequisites/part.d.ts

@@ -1,6 +1,5 @@
 import type { SentenceType } from "@optolith/database-schema/gen";
-import type { LocaleCompare } from "../../../helpers/locale.js";
-import type { Translate, TranslateMap } from "../../../helpers/translate.js";
+import type { StdReader } from "../../../env.js";
 import { type ActivatableNameComponents } from "../activatableNameChunks.js";
 /**
  * A part of the total list of prerequisites.
@@ -10,6 +9,7 @@ export type PrerequisitePart = {
     value: string | ActivatableNameComponents;
     sentenceType: SentenceType | undefined;
     isMeta: boolean;
+    isRemoved?: true;
 };
 /**
  * Type guard for prerequisite parts with a value object.
@@ -20,7 +20,7 @@ export declare const hasPartValueObject: (part: PrerequisitePart) => part is Pre
 /**
  * Join prerequisite parts using their configuration.
  */
-export declare const joinPrerequisiteParts: (translate: Translate, translateMap: TranslateMap, localeCompare: LocaleCompare, parts: {
+export declare const joinPrerequisiteParts: (parts: {
     type: string;
     part: PrerequisitePart;
-}[]) => string;
+}[]) => StdReader<string, "t" | "tm" | "lc">;

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

@@ -2,10 +2,12 @@ import { groupBy } from "@elyukai/utils/array/groups";
 import { deepEqual, equal } from "@elyukai/utils/equality";
 import { on } from "@elyukai/utils/function";
 import { compareNumber, reduceCompare } from "@elyukai/utils/ordering";
+import { Reader } from "@elyukai/utils/reader";
 import { assertExhaustive } from "@optolith/helpers/typeSafety";
 import { fromUniformCase } from "tsondb/schema/gen";
 import { renderActivatableNameComponents, renderActivatableNameComponentsCombinedIfPossible, } from "../activatableNameChunks.js";
 import { attributedInstance } from "../markdown.js";
+import { translateR } from "../reader.js";
 /**
  * Type guard for prerequisite parts with a value object.
  */
@@ -13,18 +15,19 @@ export const hasPartValueObject = (part) => typeof part.value !== "string";
 const countFurtherToCombined = (part, remainingParts) => {
     const indexHasDifferentBaseValues = remainingParts.findIndex(remaining => !(part.label === remaining.label &&
         deepEqual(part.value.id, remaining.value.id) &&
-        part.value.level === remaining.value.level));
+        part.value.level === remaining.value.level &&
+        part.isRemoved === remaining.isRemoved));
     return indexHasDifferentBaseValues === -1
         ? // if -1 is returned, all remaining parts have the same base values, so we can combine with all of them
             remainingParts.length
         : indexHasDifferentBaseValues;
 };
 const wrapActivatableInAttributedString = (text, id) => attributedInstance(text, id.kind, fromUniformCase(id), { context: '"prerequisite"' });
-const joinAdjacentParts = (translateMap, localeCompare, part, remainingParts) => {
+const joinAdjacentParts = (translate, translateMap, localeCompare, part, remainingParts) => {
     const valuesWithSameBase = remainingParts.slice(0, countFurtherToCombined(part, remainingParts));
     if (valuesWithSameBase.length > 0) {
         return [
-            wrapActivatableInAttributedString(renderActivatableNameComponentsCombinedIfPossible(translateMap, [part.value, ...valuesWithSameBase.map(p => p.value)], true, list => list.toSorted(localeCompare).join(", ")), part.value.id),
+            renderActivatableNameComponentsCombinedIfPossible(translate, translateMap, [part.value, ...valuesWithSameBase.map(p => p.value)], true, list => list.toSorted(localeCompare).join(", ")),
             valuesWithSameBase.length,
         ];
     }
@@ -53,43 +56,49 @@ const activatableKindToGroup = (kind) => kind === "Advantage" ? "Advantage" : ki
 const activatableGroupOrder = ["Advantage", "Disadvantage", "SpecialAbility"];
 const sortByActivatableGroup = on(group => activatableGroupOrder.indexOf(group), compareNumber);
 const sortByActivatableGroupAndName = (localeCompare) => reduceCompare(on(item => item[0], sortByActivatableGroup), on(item => item[1], localeCompare));
-const appendPrerequisitePartGroup = (previous, translateMap, localeCompare, parts, isLast) => {
+const appendPrerequisitePartGroup = (previous, parts, isLast) => {
     if (parts.length === 0) {
-        return previous;
+        return Reader.of(previous);
     }
-    else if (parts.every(hasPartValueObject)) {
-        return appendBySentenceType(previous, parts
+    const wrapInNoPrerequisite = (text) => parts[0]?.isRemoved === true
+        ? translateR("no prerequisite {$prerequisite}", { prerequisite: text })
+        : Reader.of(text);
+    if (parts.every(hasPartValueObject)) {
+        return Reader.asks(({ translate, translateMap, localeCompare }) => appendBySentenceType(previous, wrapInNoPrerequisite(parts
             .toSorted(on(part => fromUniformCase(part.value.id), localeCompare))
             .reduce((acc, current, i, arr) => {
             if (acc[1] > 0) {
                 return [acc[0], acc[1] - 1];
             }
-            const [rendered, furtherIncluded] = joinAdjacentParts(translateMap, localeCompare, current, arr.slice(i + 1));
+            const [rendered, furtherIncluded] = joinAdjacentParts(translate, translateMap, localeCompare, current, arr.slice(i + 1));
             return [
                 [
                     ...acc[0],
-                    [activatableKindToGroup(current.value.id.kind), (current.label ?? "") + rendered],
+                    [
+                        activatableKindToGroup(current.value.id.kind),
+                        (current.label ?? "") + rendered,
+                    ],
                 ],
                 furtherIncluded,
             ];
         }, [[], 0])[0]
             .toSorted(sortByActivatableGroupAndName(localeCompare))
             .map(grouped => grouped[1])
-            .join(", "), undefined, isLast);
+            .join(", ")).run({ translate }), undefined, isLast));
     }
     else {
-        return parts.reduce((acc, current, i, arr) => appendBySentenceType(acc, (current.label ?? "") +
+        return Reader.asks(({ translate, translateMap }) => parts.reduce((acc, current, i, arr) => appendBySentenceType(acc, wrapInNoPrerequisite((current.label ?? "") +
             (typeof current.value === "string"
                 ? current.value
-                : wrapActivatableInAttributedString(renderActivatableNameComponents(translateMap, current.value, true), current.value.id)), current.sentenceType, isLast && i === arr.length - 1), previous);
+                : wrapActivatableInAttributedString(renderActivatableNameComponents(translateMap, current.value, true), current.value.id))).run({ translate }), current.sentenceType, isLast && i === arr.length - 1), previous));
     }
 };
 /**
  * Join prerequisite parts using their configuration.
  */
-export const joinPrerequisiteParts = (translate, translateMap, localeCompare, parts) => groupBy(parts, on(part => part.type, equal))
+export const joinPrerequisiteParts = (parts) => groupBy(parts, on(part => part.type, equal))
     .map(group => ({
     type: group[0].type,
     parts: group.map(groupItem => groupItem.part),
 }))
-    .reduce((acc, partGroup, i, arr) => appendPrerequisitePartGroup(acc, translateMap, localeCompare, partGroup.parts, i === arr.length - 1), parts.every(({ part }) => part.isMeta) ? translate("none") : "");
+    .reduce((accR, partGroup, i, arr) => accR.thenW(acc => appendPrerequisitePartGroup(acc, partGroup.parts, i === arr.length - 1)), parts.every(({ part }) => part.isMeta) ? translateR("none") : Reader.of(""));

package/lib/entities/partial/prerequisites/prerequisiteGroups.d.ts

@@ -1,65 +1,63 @@
 import type { ActivatableIdentifier, AdvantageDisadvantagePrerequisiteGroup, AnimistPowerPrerequisiteGroup, ArcaneTraditionPrerequisiteGroup, DerivedCharacteristicPrerequisiteGroup, EnhancementPrerequisiteGroup, GeneralPrerequisiteGroup, GeodeRitualPrerequisiteGroup, InfluencePrerequisiteGroup, LanguagePrerequisiteGroup, LiturgyPrerequisiteGroup, PersonalityTraitPrerequisiteGroup, PreconditionGroup, ProfessionPrerequisiteGroup, PublicationPrerequisiteGroup, RatedIdentifier, SpellworkPrerequisiteGroup } from "@optolith/database-schema/gen";
-import type { GetAllChildInstancesForParent, GetInstanceById } from "../../../helpers/getTypes.js";
-import type { LocaleEnvironment } from "../../../helpers/locale.js";
+import type { StdReader } from "../../../env.js";
 import type { PrerequisitePart } from "./part.js";
-import { type GetResolvedSelectOptionById } from "./single/activatable.js";
 /**
  * Print the translation of a derived characteristic prerequisite group.
  */
-export declare const printDerivedCharacteristicPrerequisiteGroup: (locale: LocaleEnvironment, prerequisite: DerivedCharacteristicPrerequisiteGroup) => PrerequisitePart | undefined;
+export declare const printDerivedCharacteristicPrerequisiteGroup: (prerequisite: DerivedCharacteristicPrerequisiteGroup) => StdReader<PrerequisitePart | undefined, "t" | "tm">;
 /**
  * Print the translation of a publication prerequisite group.
  */
-export declare const printPublicationPrerequisiteGroup: (getInstanceById: GetInstanceById<"Publication">, locale: LocaleEnvironment, prerequisite: PublicationPrerequisiteGroup) => PrerequisitePart | undefined;
+export declare const printPublicationPrerequisiteGroup: (prerequisite: PublicationPrerequisiteGroup) => StdReader<PrerequisitePart | undefined, "t" | "tm" | "ibi", "Publication">;
 /**
  * Print the translation of a general prerequisite group.
  */
-export declare const printGeneralPrerequisiteGroup: (getInstanceById: GetInstanceById<"Race" | "Culture" | "PactCategory" | "PactDomain" | "SocialStatus" | "State" | ActivatableIdentifier["kind"] | RatedIdentifier["kind"] | "Property" | "Aspect" | "Enhancement" | "PersonalityTrait" | "Blessing" | "Cantrip">, getResolvedSelectOptionById: GetResolvedSelectOptionById, locale: LocaleEnvironment, prerequisite: GeneralPrerequisiteGroup) => PrerequisitePart | undefined;
+export declare const printGeneralPrerequisiteGroup: (prerequisite: GeneralPrerequisiteGroup) => StdReader<PrerequisitePart | undefined, "t" | "tm" | "lj" | "lc" | "rso" | "ibi", "Race" | "Culture" | "PactCategory" | "PactDomain" | "SocialStatus" | "State" | ActivatableIdentifier["kind"] | RatedIdentifier["kind"] | "Property" | "Aspect" | "Enhancement" | "PersonalityTrait" | "Blessing" | "Cantrip">;
 /**
  * Print the translation of a profession prerequisite group.
  */
-export declare const printProfessionPrerequisiteGroup: (getInstanceById: GetInstanceById<"Race" | "Culture" | ActivatableIdentifier["kind"] | RatedIdentifier["kind"] | "Aspect">, getResolvedSelectOptionById: GetResolvedSelectOptionById, locale: Pick<LocaleEnvironment, "translate" | "translateMap">, prerequisite: ProfessionPrerequisiteGroup) => PrerequisitePart | undefined;
+export declare const printProfessionPrerequisiteGroup: (prerequisite: ProfessionPrerequisiteGroup) => StdReader<PrerequisitePart | undefined, "t" | "tm" | "rso" | "ibi", "Race" | "Culture" | ActivatableIdentifier["kind"] | RatedIdentifier["kind"] | "Aspect">;
 /**
  * Print the translation of an advantage/disadvantage prerequisite group.
  */
-export declare const printAdvantageDisadvantagePrerequisiteGroup: (getInstanceById: GetInstanceById<"Race" | "Culture" | "PactCategory" | "PactDomain" | "SocialStatus" | "State" | ActivatableIdentifier["kind"] | RatedIdentifier["kind"] | "Property" | "Aspect" | "Enhancement" | "PersonalityTrait" | "Blessing" | "Cantrip">, getResolvedSelectOptionById: GetResolvedSelectOptionById, locale: LocaleEnvironment, prerequisite: AdvantageDisadvantagePrerequisiteGroup, name: string, type: "Advantage" | "Disadvantage") => PrerequisitePart | undefined;
+export declare const printAdvantageDisadvantagePrerequisiteGroup: (prerequisite: AdvantageDisadvantagePrerequisiteGroup, name: string, type: "Advantage" | "Disadvantage") => StdReader<PrerequisitePart | undefined, "t" | "tm" | "lj" | "lc" | "rso" | "ibi", "Race" | "Culture" | "PactCategory" | "PactDomain" | "SocialStatus" | "State" | ActivatableIdentifier["kind"] | RatedIdentifier["kind"] | "Property" | "Aspect" | "Enhancement" | "PersonalityTrait" | "Blessing" | "Cantrip">;
 /**
  * Print the translation of an arcane tradition prerequisite group.
  */
-export declare const printArcaneTraditionPrerequisiteGroup: (getInstanceById: GetInstanceById<"Culture">, locale: LocaleEnvironment, prerequisite: ArcaneTraditionPrerequisiteGroup) => PrerequisitePart | undefined;
+export declare const printArcaneTraditionPrerequisiteGroup: (prerequisite: ArcaneTraditionPrerequisiteGroup) => StdReader<PrerequisitePart | undefined, "t" | "tm" | "ibi", "Culture">;
 /**
  * Print the translation of a personality trait prerequisite group.
  */
-export declare const printPersonalityTraitPrerequisiteGroup: (getInstanceById: GetInstanceById<"Race" | "Culture" | "PersonalityTrait">, locale: LocaleEnvironment, prerequisite: PersonalityTraitPrerequisiteGroup) => PrerequisitePart | undefined;
+export declare const printPersonalityTraitPrerequisiteGroup: (prerequisite: PersonalityTraitPrerequisiteGroup) => StdReader<PrerequisitePart | undefined, "t" | "tm" | "ibi", "Race" | "Culture" | "PersonalityTrait">;
 /**
  * Print the translation of a spellwork prerequisite group.
  */
-export declare const printSpellworkPrerequisiteGroup: (getInstanceById: GetInstanceById<RatedIdentifier["kind"]>, locale: LocaleEnvironment, prerequisite: SpellworkPrerequisiteGroup) => PrerequisitePart | undefined;
+export declare const printSpellworkPrerequisiteGroup: (prerequisite: SpellworkPrerequisiteGroup) => StdReader<PrerequisitePart | undefined, "t" | "tm" | "ibi", RatedIdentifier["kind"]>;
 /**
  * Print the translation of a liturgy prerequisite group.
  */
-export declare const printLiturgyPrerequisiteGroup: (locale: LocaleEnvironment, prerequisite: LiturgyPrerequisiteGroup) => PrerequisitePart | undefined;
+export declare const printLiturgyPrerequisiteGroup: (prerequisite: LiturgyPrerequisiteGroup) => StdReader<PrerequisitePart | undefined, never>;
 /**
  * Print the translation of an influence prerequisite group.
  */
-export declare const printInfluencePrerequisiteGroup: (getInstanceById: GetInstanceById<"Influence" | "Race" | ActivatableIdentifier["kind"] | "Aspect">, getResolvedSelectOptionById: GetResolvedSelectOptionById, getChildInstancesForInstanceId: GetAllChildInstancesForParent<"ProfessionVersion">, locale: LocaleEnvironment, prerequisite: InfluencePrerequisiteGroup) => PrerequisitePart | undefined;
+export declare const printInfluencePrerequisiteGroup: (prerequisite: InfluencePrerequisiteGroup) => StdReader<PrerequisitePart | undefined, "t" | "tm" | "rso" | "ibi" | "acibp", "Influence" | "Race" | ActivatableIdentifier["kind"] | "Aspect", never, "ProfessionVersion">;
 /**
  * Print the translation of a language prerequisite group.
  */
-export declare const printLanguagePrerequisiteGroup: (getInstanceById: GetInstanceById<"Race" | ActivatableIdentifier["kind"] | "Aspect">, getResolvedSelectOptionById: GetResolvedSelectOptionById, locale: LocaleEnvironment, prerequisite: LanguagePrerequisiteGroup) => PrerequisitePart | undefined;
+export declare const printLanguagePrerequisiteGroup: (prerequisite: LanguagePrerequisiteGroup) => StdReader<PrerequisitePart | undefined, "t" | "tm" | "rso" | "ibi", "Race" | ActivatableIdentifier["kind"] | "Aspect">;
 /**
  * Print the translation of an animist power prerequisite group.
  */
-export declare const printAnimistPowerPrerequisiteGroup: (getInstanceById: GetInstanceById<"AnimistPower">, locale: LocaleEnvironment, prerequisite: AnimistPowerPrerequisiteGroup) => PrerequisitePart | undefined;
+export declare const printAnimistPowerPrerequisiteGroup: (prerequisite: AnimistPowerPrerequisiteGroup) => StdReader<PrerequisitePart | undefined, "tm" | "ibi", "AnimistPower">;
 /**
  * Print the translation of a geode ritual prerequisite group.
  */
-export declare const printGeodeRitualPrerequisiteGroup: (getInstanceById: GetInstanceById<"Influence" | ActivatableIdentifier["kind"] | "Aspect">, getResolvedSelectOptionById: GetResolvedSelectOptionById, locale: LocaleEnvironment, prerequisite: GeodeRitualPrerequisiteGroup) => PrerequisitePart | undefined;
+export declare const printGeodeRitualPrerequisiteGroup: (prerequisite: GeodeRitualPrerequisiteGroup) => StdReader<PrerequisitePart | undefined, "t" | "tm" | "rso" | "ibi", ActivatableIdentifier["kind"] | "Aspect" | "Influence">;
 /**
  * Print the translation of an enhancement prerequisite group.
  */
-export declare const printEnhancementPrerequisiteGroup: (getInstanceById: GetInstanceById<RatedIdentifier["kind"] | "Enhancement">, locale: Pick<LocaleEnvironment, "translate" | "translateMap">, prerequisite: EnhancementPrerequisiteGroup) => PrerequisitePart | undefined;
+export declare const printEnhancementPrerequisiteGroup: (prerequisite: EnhancementPrerequisiteGroup) => StdReader<PrerequisitePart | undefined, "t" | "tm" | "ibi", RatedIdentifier["kind"] | "Enhancement">;
 /**
  * Print the translation of a precondition group.
  */
-export declare const printPreconditionGroup: (getInstanceById: GetInstanceById<"Publication">, locale: LocaleEnvironment, prerequisite: PreconditionGroup) => PrerequisitePart | undefined;
+export declare const printPreconditionGroup: (prerequisite: PreconditionGroup) => StdReader<PrerequisitePart | undefined, "t" | "tm" | "ibi", "Publication">;