@optolith/entity-descriptions 0.2.1 → 0.3.2

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

@@ -0,0 +1,189 @@
+import { on } from "@elyukai/utils/function";
+import { mapNullable } from "@elyukai/utils/nullable";
+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 { 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,
+    sentenceType: undefined,
+    isMeta: false,
+});
+const printPrerequisitesDisjunction = (getPrerequisiteTranslation, locale, disjunction) => {
+    if (disjunction.display_option !== undefined) {
+        return printDisplayOption(locale.translateMap, disjunction.display_option);
+    }
+    const [first, ...other] = disjunction.list.map(getPrerequisiteTranslation).filter(isNotNullish);
+    if (first === undefined) {
+        return undefined;
+    }
+    if (disjunction.list.length < 2 ||
+        disjunction.list.slice(1).every(part => part.kind === disjunction.list[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"
+                    ? part.value
+                    : renderActivatableNameComponents(locale.translateMap, part.value, true)), "disjunction"),
+            sentenceType: undefined,
+            isMeta: false,
+        };
+    }
+    return {
+        value: locale.join([first, ...other].map(part => (part.label ?? "") + part.value), "disjunction"),
+        sentenceType: undefined,
+        isMeta: false,
+    };
+};
+/**
+ * Print prerequisites element as a string.
+ */
+const printPrerequisitesElement = (printPrerequisite, locale, element) => {
+    switch (element.kind) {
+        case "Single":
+            return printPrerequisite(element.Single);
+        case "Disjunction":
+            return printPrerequisitesDisjunction(printPrerequisite, locale, element.Disjunction);
+        case "Group":
+            return printPrerequisiteGroup(locale.translateMap, element.Group);
+        default:
+            return assertExhaustive(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 => ({
+    type: element.kind === "Single" ? element.Single.kind : element.kind,
+    part,
+})))
+    .filter(isNotNullish));
+/**
+ * Print prerequisite for level as a string.
+ */
+const printPrerequisiteForLevel = (printPrerequisite, locale, value) => printPrerequisitesElement(printPrerequisite, locale, value.prerequisite);
+/**
+ * Print prerequisites for levels as a string.
+ */
+const printPrerequisitesForLevels = (printPrerequisite, locale, value, printPreviousLevelPrerequisites) => {
+    const previousLevelPrerequisites = printPreviousLevelPrerequisites === undefined
+        ? []
+        : Array.from({ length: printPreviousLevelPrerequisites.levels - 1 }, (_, i) => ({
+            level: i + 2,
+            prerequisite: {
+                kind: "Single",
+                Single: printPreviousLevelPrerequisites.createPreerequisite(i + 2),
+            },
+        }));
+    const groupedByLevel = Map.groupBy([...value, ...previousLevelPrerequisites], prerequisite => prerequisite.level);
+    const hasBasePrerequisites = groupedByLevel.has(1);
+    const sortedByLevel = groupedByLevel
+        .entries()
+        .toArray()
+        .sort(on(item => item[0], numAsc));
+    const hasOnlyBasePrerequisites = groupedByLevel.size === 1 && hasBasePrerequisites;
+    const printedParts = [
+        ...(hasBasePrerequisites
+            ? []
+            : [
+                `${locale.translate("Level {$level}", {
+                    level: romanize(1),
+                })}: ${locale.translate("none")}`,
+            ]),
+        ...sortedByLevel.map(([levelNumber, prerequisites]) => {
+            const prerequisitesString = joinPrerequisiteParts(locale.translate, locale.translateMap, locale.compare, prerequisites
+                .map(element => mapNullable(printPrerequisiteForLevel(printPrerequisite, locale, element), part => ({
+                type: element.prerequisite.kind === "Single"
+                    ? element.prerequisite.Single.kind
+                    : element.prerequisite.kind,
+                part,
+            })))
+                .filter(isNotNullish));
+            return hasOnlyBasePrerequisites
+                ? prerequisitesString
+                : `${locale.translate("Level {$level}", {
+                    level: romanize(levelNumber),
+                })}: ${prerequisitesString}`;
+        }),
+    ];
+    return printedParts.join("; ");
+};
+/**
+ * Print derived characteristic prerequisites as a string.
+ */
+export const printDerivedCharacteristicPrerequisites = (locale, value) => printPlainPrerequisites(prerequisite => printDerivedCharacteristicPrerequisiteGroup(locale, prerequisite), locale, value);
+/**
+ * Print publication prerequisites as a string.
+ */
+export const printPublicationPrerequisites = (getInstanceById, locale, value) => printPlainPrerequisites(prerequisite => printPublicationPrerequisiteGroup(getInstanceById, locale, prerequisite), locale, value);
+/**
+ * Print plain general prerequisites as a string.
+ */
+export const printPlainGeneralPrerequisites = (getInstanceById, getResolvedSelectOptionById, locale, value) => printPlainPrerequisites(prerequisite => printGeneralPrerequisiteGroup(getInstanceById, getResolvedSelectOptionById, locale, prerequisite), locale, value);
+/**
+ * Print general prerequisites as a string.
+ */
+export const printGeneralPrerequisites = (getInstanceById, getResolvedSelectOptionById, locale, value, printPreviousLevelPrerequisites) => printPrerequisitesForLevels(prerequisite => printGeneralPrerequisiteGroup(getInstanceById, getResolvedSelectOptionById, locale, prerequisite), locale, value, printPreviousLevelPrerequisites === undefined
+    ? undefined
+    : {
+        levels: printPreviousLevelPrerequisites.levels,
+        createPreerequisite: (level) => ({
+            kind: "Activatable",
+            Activatable: {
+                id: printPreviousLevelPrerequisites.id,
+                active: true,
+                level,
+            },
+        }),
+    });
+/**
+ * Print profession prerequisites as a string.
+ */
+export const printProfessionPrerequisites = (getInstanceById, getResolvedSelectOptionById, locale, value) => printPlainPrerequisites(prerequisite => printProfessionPrerequisiteGroup(getInstanceById, getResolvedSelectOptionById, locale, prerequisite), locale, 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);
+/**
+ * Print arcane tradition prerequisites as a string.
+ */
+export const printArcaneTraditionPrerequisites = (getInstanceById, locale, value) => printPlainPrerequisites(prerequisite => printArcaneTraditionPrerequisiteGroup(getInstanceById, locale, prerequisite), locale, value);
+/**
+ * Print personality trait prerequisites as a string.
+ */
+export const printPersonalityTraitPrerequisites = (getInstanceById, locale, value) => printPlainPrerequisites(prerequisite => printPersonalityTraitPrerequisiteGroup(getInstanceById, locale, prerequisite), locale, value);
+/**
+ * Print spellwork prerequisites as a string.
+ */
+export const printSpellworkPrerequisites = (getInstanceById, locale, value) => printPlainPrerequisites(prerequisite => printSpellworkPrerequisiteGroup(getInstanceById, locale, prerequisite), locale, value);
+/**
+ * Print liturgy prerequisites as a string.
+ */
+export const printLiturgyPrerequisites = (locale, value) => printPlainPrerequisites(prerequisite => printLiturgyPrerequisiteGroup(locale, prerequisite), locale, 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);
+/**
+ * Print language prerequisites as a string.
+ */
+export const printLanguagePrerequisites = (getInstanceById, getResolvedSelectOptionById, locale, value) => printPrerequisitesForLevels(prerequisite => printLanguagePrerequisiteGroup(getInstanceById, getResolvedSelectOptionById, locale, prerequisite), locale, value);
+/**
+ * Print animist power prerequisites as a string.
+ */
+export const printAnimistPowerPrerequisites = (getInstanceById, locale, value) => printPlainPrerequisites(prerequisite => printAnimistPowerPrerequisiteGroup(getInstanceById, locale, prerequisite), locale, value);
+/**
+ * Print geode ritual prerequisites as a string.
+ */
+export const printGeodeRitualPrerequisites = (getInstanceById, locale, value) => printPlainPrerequisites(prerequisite => printGeodeRitualPrerequisiteGroup(getInstanceById, locale, prerequisite), locale, value);
+/**
+ * Print enhancement prerequisites as a string.
+ */
+export const printEnhancementPrerequisites = (getInstanceById, locale, value) => printPlainPrerequisites(prerequisite => printEnhancementPrerequisiteGroup(getInstanceById, locale, prerequisite), locale, value);

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

@@ -0,0 +1,26 @@
+import { SentenceType } from "optolith-database-schema/gen";
+import type { LocaleCompare } from "../../../helpers/locale.js";
+import type { Translate, TranslateMap } from "../../../helpers/translate.js";
+import { type ActivatableNameComponents } from "../activatableNameChunks.js";
+/**
+ * A part of the total list of prerequisites.
+ */
+export type PrerequisitePart = {
+    label?: string;
+    value: string | ActivatableNameComponents;
+    sentenceType: SentenceType | undefined;
+    isMeta: boolean;
+};
+/**
+ * Type guard for prerequisite parts with a value object.
+ */
+export declare const hasPartValueObject: (part: PrerequisitePart) => part is PrerequisitePart & {
+    value: ActivatableNameComponents;
+};
+/**
+ * Join prerequisite parts using their configuration.
+ */
+export declare const joinPrerequisiteParts: (translate: Translate, translateMap: TranslateMap, localeCompare: LocaleCompare, parts: {
+    type: string;
+    part: PrerequisitePart;
+}[]) => string;

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

@@ -0,0 +1,88 @@
+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 { assertExhaustive } from "@optolith/helpers/typeSafety";
+import { renderActivatableNameComponents, renderActivatableNameComponentsCombinedIfPossible, } from "../activatableNameChunks.js";
+/**
+ * Type guard for prerequisite parts with a value object.
+ */
+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));
+    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 joinAdjacentParts = (translateMap, localeCompare, part, remainingParts) => {
+    const valuesWithSameBase = remainingParts.slice(0, countFurtherToCombined(part, remainingParts));
+    if (valuesWithSameBase.length > 0) {
+        return [
+            renderActivatableNameComponentsCombinedIfPossible(translateMap, [part.value, ...valuesWithSameBase.map(p => p.value)], true, list => list.toSorted(localeCompare).join(", ")),
+            valuesWithSameBase.length,
+        ];
+    }
+    return [renderActivatableNameComponents(translateMap, part.value, true), 0];
+};
+const appendBySentenceType = (previouslyRendered, currentRendered, sentenceType, isLast) => {
+    switch (sentenceType?.kind) {
+        case "Standalone":
+            return `${/[.;]$/u.test(previouslyRendered)
+                ? `${previouslyRendered.slice(0, -1)}. `
+                : `${previouslyRendered}. `}${currentRendered}${currentRendered.endsWith(".") ? "" : "."}`;
+        case "Connected":
+            return `${previouslyRendered === "" ? "" : /[.;]$/u.test(previouslyRendered) ? `${previouslyRendered} ` : `${previouslyRendered}; `}${currentRendered}${isLast ? "" : ";"}`;
+        case undefined:
+            return previouslyRendered === ""
+                ? currentRendered
+                : `${previouslyRendered}${/[.;]$/u.test(previouslyRendered) ? " " : ", "}${currentRendered}`;
+        default:
+            return assertExhaustive(sentenceType);
+    }
+};
+const activatableKindToGroup = (kind) => kind === "Advantage" ? "Advantage" : kind === "Disadvantage" ? "Disadvantage" : "SpecialAbility";
+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) => {
+    if (parts.length === 0) {
+        return previous;
+    }
+    else if (parts.every(hasPartValueObject)) {
+        return appendBySentenceType(previous, parts
+            .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));
+            return [
+                [
+                    ...acc[0],
+                    [activatableKindToGroup(current.value.id.kind), (current.label ?? "") + rendered],
+                ],
+                furtherIncluded,
+            ];
+        }, [[], 0])[0]
+            .toSorted(sortByActivatableGroupAndName(localeCompare))
+            .map(grouped => grouped[1])
+            .join(", "), undefined, isLast);
+    }
+    else {
+        return parts.reduce((acc, current, i, arr) => appendBySentenceType(acc, (current.label ?? "") +
+            (typeof current.value === "string"
+                ? current.value
+                : renderActivatableNameComponents(translateMap, current.value, true)), 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))
+    .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") : "");

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

@@ -0,0 +1,65 @@
+import { AdvantageDisadvantagePrerequisiteGroup, AnimistPowerPrerequisiteGroup, ArcaneTraditionPrerequisiteGroup, DerivedCharacteristicPrerequisiteGroup, EnhancementPrerequisiteGroup, GeneralPrerequisiteGroup, GeodeRitualPrerequisiteGroup, InfluencePrerequisiteGroup, LanguagePrerequisiteGroup, LiturgyPrerequisiteGroup, PersonalityTraitPrerequisiteGroup, PreconditionGroup, ProfessionPrerequisiteGroup, PublicationPrerequisiteGroup, SpellworkPrerequisiteGroup, type ActivatableIdentifier, type RatedIdentifier } from "optolith-database-schema/gen";
+import type { GetAllChildInstancesForParent, GetInstanceById } from "../../../helpers/getTypes.js";
+import { LocaleEnvironment } from "../../../helpers/locale.js";
+import { PrerequisitePart } from "./part.js";
+import { GetResolvedSelectOptionById } from "./single/activatable.js";
+/**
+ * Print the translation of a derived characteristic prerequisite group.
+ */
+export declare const printDerivedCharacteristicPrerequisiteGroup: (locale: LocaleEnvironment, prerequisite: DerivedCharacteristicPrerequisiteGroup) => PrerequisitePart | undefined;
+/**
+ * Print the translation of a publication prerequisite group.
+ */
+export declare const printPublicationPrerequisiteGroup: (getInstanceById: GetInstanceById<"Publication">, locale: LocaleEnvironment, prerequisite: PublicationPrerequisiteGroup) => PrerequisitePart | undefined;
+/**
+ * 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">, getResolvedSelectOptionById: GetResolvedSelectOptionById, locale: LocaleEnvironment, prerequisite: GeneralPrerequisiteGroup) => PrerequisitePart | undefined;
+/**
+ * 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;
+/**
+ * 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">, getResolvedSelectOptionById: GetResolvedSelectOptionById, locale: LocaleEnvironment, prerequisite: AdvantageDisadvantagePrerequisiteGroup, name: string, type: "Advantage" | "Disadvantage") => PrerequisitePart | undefined;
+/**
+ * Print the translation of an arcane tradition prerequisite group.
+ */
+export declare const printArcaneTraditionPrerequisiteGroup: (getInstanceById: GetInstanceById<"Culture">, locale: LocaleEnvironment, prerequisite: ArcaneTraditionPrerequisiteGroup) => PrerequisitePart | undefined;
+/**
+ * Print the translation of a personality trait prerequisite group.
+ */
+export declare const printPersonalityTraitPrerequisiteGroup: (getInstanceById: GetInstanceById<"Race" | "Culture" | "PersonalityTrait">, locale: LocaleEnvironment, prerequisite: PersonalityTraitPrerequisiteGroup) => PrerequisitePart | undefined;
+/**
+ * Print the translation of a spellwork prerequisite group.
+ */
+export declare const printSpellworkPrerequisiteGroup: (getInstanceById: GetInstanceById<RatedIdentifier["kind"]>, locale: LocaleEnvironment, prerequisite: SpellworkPrerequisiteGroup) => PrerequisitePart | undefined;
+/**
+ * Print the translation of a liturgy prerequisite group.
+ */
+export declare const printLiturgyPrerequisiteGroup: (locale: LocaleEnvironment, prerequisite: LiturgyPrerequisiteGroup) => PrerequisitePart | undefined;
+/**
+ * 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;
+/**
+ * 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;
+/**
+ * Print the translation of an animist power prerequisite group.
+ */
+export declare const printAnimistPowerPrerequisiteGroup: (getInstanceById: GetInstanceById<"AnimistPower">, locale: LocaleEnvironment, prerequisite: AnimistPowerPrerequisiteGroup) => PrerequisitePart | undefined;
+/**
+ * Print the translation of a geode ritual prerequisite group.
+ */
+export declare const printGeodeRitualPrerequisiteGroup: (getInstanceById: GetInstanceById<"Influence">, locale: LocaleEnvironment, prerequisite: GeodeRitualPrerequisiteGroup) => PrerequisitePart | undefined;
+/**
+ * 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;
+/**
+ * Print the translation of a precondition group.
+ */
+export declare const printPreconditionGroup: (getInstanceById: GetInstanceById<"Publication">, locale: LocaleEnvironment, prerequisite: PreconditionGroup) => PrerequisitePart | undefined;

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

@@ -0,0 +1,278 @@
+import { assertExhaustive } from "@optolith/helpers/typeSafety";
+import { printActivatablePrerequisite } from "./single/activatable.js";
+import { printAnimistPowerPrerequisite } from "./single/animistPower.js";
+import { printBlessedTraditionPrerequisite } from "./single/blessedTradition.js";
+import { printCommonSuggestedByRCPPrerequisite } from "./single/commonSuggestedByRCP.js";
+import { printCulturePrerequisite } from "./single/culture.js";
+import { printEnhancementPrerequisite } from "./single/enhancement.js";
+import { printInfluencePrerequisite } from "./single/influence.js";
+import { printMagicalTraditionPrerequisite } from "./single/magicalTradition.js";
+import { printNoOtherAncestorBloodAdvantagePrerequisite } from "./single/noOtherAncestorBloodAdvantage.js";
+import { printPactPrerequisite } from "./single/pact.js";
+import { printPersonalityTraitPrerequisite } from "./single/personalityTrait.js";
+import { printPrimaryAttributePrerequisite } from "./single/primaryAttribute.js";
+import { printProfessionPrerequisite } from "./single/profession.js";
+import { printPublicationPrerequisite } from "./single/publication.js";
+import { printRacePrerequisite } from "./single/race.js";
+import { printRatedPrerequisite } from "./single/rated.js";
+import { printRatedMinimumNumberPrerequisite } from "./single/ratedMinimumNumber.js";
+import { printRatedSumPrerequisite } from "./single/ratedSum.js";
+import { printRulePrerequisite } from "./single/rule.js";
+import { printBinarySexPrerequisite } from "./single/sex.js";
+import { printSexualCharacteristicPrerequisite } from "./single/sexualCharacteristic.js";
+import { printSocialStatusPrerequisite } from "./single/socialStatus.js";
+import { printStatePrerequisite } from "./single/state.js";
+import { printTextPrerequisite } from "./single/text.js";
+/**
+ * Print the translation of a derived characteristic prerequisite group.
+ */
+export const printDerivedCharacteristicPrerequisiteGroup = (locale, prerequisite) => {
+    switch (prerequisite.kind) {
+        case "Rule":
+            return printRulePrerequisite(locale, prerequisite.Rule);
+        case "BlessedTradition":
+            return printBlessedTraditionPrerequisite(locale, prerequisite.BlessedTradition);
+        case "MagicalTradition":
+            return printMagicalTraditionPrerequisite(locale, prerequisite.MagicalTradition);
+        default:
+            return assertExhaustive(prerequisite);
+    }
+};
+/**
+ * Print the translation of a publication prerequisite group.
+ */
+export const printPublicationPrerequisiteGroup = (getInstanceById, locale, prerequisite) => 
+// switch (prerequisite.tag) {
+//   case "Publication":
+//   default:
+//     return assertExhaustive(prerequisite)
+// }
+printPublicationPrerequisite(getInstanceById, locale, prerequisite.Publication);
+/**
+ * Print the translation of a general prerequisite group.
+ */
+export const printGeneralPrerequisiteGroup = (getInstanceById, getResolvedSelectOptionById, locale, prerequisite) => {
+    switch (prerequisite.kind) {
+        case "Sex":
+            return printBinarySexPrerequisite(locale.translate, prerequisite.Sex);
+        case "Race":
+            return printRacePrerequisite(getInstanceById, locale, prerequisite.Race);
+        case "Culture":
+            return printCulturePrerequisite(getInstanceById, locale, prerequisite.Culture);
+        case "Pact":
+            return printPactPrerequisite(getInstanceById, locale, prerequisite.Pact);
+        case "SocialStatus":
+            return printSocialStatusPrerequisite(getInstanceById, locale, prerequisite.SocialStatus);
+        case "State":
+            return printStatePrerequisite(getInstanceById, locale, prerequisite.State);
+        case "Rule":
+            return printRulePrerequisite(locale, prerequisite.Rule);
+        case "PrimaryAttribute":
+            return printPrimaryAttributePrerequisite(locale, prerequisite.PrimaryAttribute);
+        case "Activatable":
+            return printActivatablePrerequisite(getInstanceById, getResolvedSelectOptionById, locale, prerequisite.Activatable, false);
+        case "BlessedTradition":
+            return printBlessedTraditionPrerequisite(locale, prerequisite.BlessedTradition);
+        case "MagicalTradition":
+            return printMagicalTraditionPrerequisite(locale, prerequisite.MagicalTradition);
+        case "Rated":
+            return printRatedPrerequisite(getInstanceById, locale, prerequisite.Rated);
+        case "RatedMinimumNumber":
+            return printRatedMinimumNumberPrerequisite(getInstanceById, locale, prerequisite.RatedMinimumNumber);
+        case "RatedSum":
+            return printRatedSumPrerequisite(getInstanceById, locale, prerequisite.RatedSum);
+        case "Enhancement":
+            return printEnhancementPrerequisite(getInstanceById, locale, prerequisite.Enhancement);
+        case "Text":
+            return printTextPrerequisite(locale, prerequisite.Text);
+        case "SexualCharacteristic":
+            return printSexualCharacteristicPrerequisite(locale, prerequisite.SexualCharacteristic);
+        default:
+            return assertExhaustive(prerequisite);
+    }
+};
+/**
+ * Print the translation of a profession prerequisite group.
+ */
+export const printProfessionPrerequisiteGroup = (getInstanceById, getResolvedSelectOptionById, locale, prerequisite) => {
+    switch (prerequisite.kind) {
+        case "Sex":
+            return printBinarySexPrerequisite(locale.translate, prerequisite.Sex);
+        case "Race":
+            return printRacePrerequisite(getInstanceById, locale, prerequisite.Race);
+        case "Culture":
+            return printCulturePrerequisite(getInstanceById, locale, prerequisite.Culture);
+        case "Activatable":
+            return printActivatablePrerequisite(getInstanceById, getResolvedSelectOptionById, locale, prerequisite.Activatable, true);
+        case "Rated":
+            return printRatedPrerequisite(getInstanceById, locale, prerequisite.Rated);
+        default:
+            return assertExhaustive(prerequisite);
+    }
+};
+/**
+ * Print the translation of an advantage/disadvantage prerequisite group.
+ */
+export const printAdvantageDisadvantagePrerequisiteGroup = (getInstanceById, getResolvedSelectOptionById, locale, prerequisite, name, type) => {
+    switch (prerequisite.kind) {
+        case "CommonSuggestedByRCP":
+            return printCommonSuggestedByRCPPrerequisite(locale, name, type);
+        case "NoOtherAncestorBloodAdvantage":
+            return printNoOtherAncestorBloodAdvantagePrerequisite(locale);
+        case "Sex":
+        case "Race":
+        case "Culture":
+        case "Pact":
+        case "SocialStatus":
+        case "State":
+        case "Rule":
+        case "PrimaryAttribute":
+        case "Activatable":
+        case "BlessedTradition":
+        case "MagicalTradition":
+        case "Rated":
+        case "RatedMinimumNumber":
+        case "RatedSum":
+        case "Enhancement":
+        case "Text":
+        case "SexualCharacteristic":
+            return printGeneralPrerequisiteGroup(getInstanceById, getResolvedSelectOptionById, locale, prerequisite);
+        default:
+            return assertExhaustive(prerequisite);
+    }
+};
+/**
+ * Print the translation of an arcane tradition prerequisite group.
+ */
+export const printArcaneTraditionPrerequisiteGroup = (getInstanceById, locale, prerequisite) => {
+    switch (prerequisite.kind) {
+        case "Sex":
+            return printBinarySexPrerequisite(locale.translate, prerequisite.Sex);
+        case "Culture":
+            return printCulturePrerequisite(getInstanceById, locale, prerequisite.Culture);
+        default:
+            return assertExhaustive(prerequisite);
+    }
+};
+/**
+ * Print the translation of a personality trait prerequisite group.
+ */
+export const printPersonalityTraitPrerequisiteGroup = (getInstanceById, locale, prerequisite) => {
+    switch (prerequisite.kind) {
+        case "Race":
+            return printRacePrerequisite(getInstanceById, locale, prerequisite.Race);
+        case "Culture":
+            return printCulturePrerequisite(getInstanceById, locale, prerequisite.Culture);
+        case "PersonalityTrait":
+            return printPersonalityTraitPrerequisite(getInstanceById, locale, prerequisite.PersonalityTrait);
+        case "Text":
+            return printTextPrerequisite(locale, prerequisite.Text);
+        default:
+            return assertExhaustive(prerequisite);
+    }
+};
+/**
+ * Print the translation of a spellwork prerequisite group.
+ */
+export const printSpellworkPrerequisiteGroup = (getInstanceById, locale, prerequisite) => {
+    switch (prerequisite.kind) {
+        case "Rule":
+            return printRulePrerequisite(locale, prerequisite.Rule);
+        case "Rated":
+            return printRatedPrerequisite(getInstanceById, locale, prerequisite.Rated);
+        default:
+            return assertExhaustive(prerequisite);
+    }
+};
+/**
+ * Print the translation of a liturgy prerequisite group.
+ */
+export const printLiturgyPrerequisiteGroup = (locale, prerequisite) => 
+// switch (prerequisite.tag) {
+//   case "Rule":
+//   default:
+//     return assertExhaustive(prerequisite)
+// }
+printRulePrerequisite(locale, prerequisite.Rule);
+/**
+ * Print the translation of an influence prerequisite group.
+ */
+export const printInfluencePrerequisiteGroup = (getInstanceById, getResolvedSelectOptionById, getChildInstancesForInstanceId, locale, prerequisite) => {
+    switch (prerequisite.kind) {
+        case "Influence":
+            return printInfluencePrerequisite(getInstanceById, locale, prerequisite.Influence);
+        case "Race":
+            return printRacePrerequisite(getInstanceById, locale, prerequisite.Race);
+        case "Profession":
+            return printProfessionPrerequisite(getChildInstancesForInstanceId, locale, prerequisite.Profession);
+        case "Activatable":
+            return printActivatablePrerequisite(getInstanceById, getResolvedSelectOptionById, locale, prerequisite.Activatable, false);
+        case "Text":
+            return printTextPrerequisite(locale, prerequisite.Text);
+        default:
+            return assertExhaustive(prerequisite);
+    }
+};
+/**
+ * Print the translation of a language prerequisite group.
+ */
+export const printLanguagePrerequisiteGroup = (getInstanceById, getResolvedSelectOptionById, locale, prerequisite) => {
+    switch (prerequisite.kind) {
+        case "Race":
+            return printRacePrerequisite(getInstanceById, locale, prerequisite.Race);
+        case "Activatable":
+            return printActivatablePrerequisite(getInstanceById, getResolvedSelectOptionById, locale, prerequisite.Activatable, false);
+        case "Text":
+            return printTextPrerequisite(locale, prerequisite.Text);
+        default:
+            return assertExhaustive(prerequisite);
+    }
+};
+/**
+ * Print the translation of an animist power prerequisite group.
+ */
+export const printAnimistPowerPrerequisiteGroup = (getInstanceById, locale, prerequisite) => 
+// switch (prerequisite.tag) {
+//   case "AnimistPower":
+//   default:
+//     return assertExhaustive(prerequisite)
+// }
+printAnimistPowerPrerequisite(getInstanceById, locale, prerequisite.AnimistPower);
+/**
+ * Print the translation of a geode ritual prerequisite group.
+ */
+export const printGeodeRitualPrerequisiteGroup = (getInstanceById, locale, prerequisite) => 
+// switch (prerequisite.tag) {
+//   case "Influence":
+//   default:
+//     return assertExhaustive(prerequisite)
+// }
+printInfluencePrerequisite(getInstanceById, locale, prerequisite.Influence);
+/**
+ * Print the translation of an enhancement prerequisite group.
+ */
+export const printEnhancementPrerequisiteGroup = (getInstanceById, locale, prerequisite) => {
+    switch (prerequisite.kind) {
+        case "Rated":
+            return printRatedPrerequisite(getInstanceById, locale, prerequisite.Rated);
+        case "Enhancement":
+            return printEnhancementPrerequisite(getInstanceById, locale, prerequisite.Enhancement);
+        default:
+            return assertExhaustive(prerequisite);
+    }
+};
+/**
+ * Print the translation of a precondition group.
+ */
+export const printPreconditionGroup = (getInstanceById, locale, prerequisite) => {
+    switch (prerequisite.kind) {
+        case "Publication":
+            return printPublicationPrerequisite(getInstanceById, locale, prerequisite.Publication);
+        case "Rule":
+            return printRulePrerequisite(locale, prerequisite.Rule);
+        case "SexualCharacteristic":
+            return printSexualCharacteristicPrerequisite(locale, prerequisite.SexualCharacteristic);
+        default:
+            return assertExhaustive(prerequisite);
+    }
+};