@optolith/entity-descriptions 0.2.1 → 0.3.1

package/lib/entities/combatTechnique.d.ts

@@ -1,15 +1,13 @@
-import { CloseCombatTechnique } from "optolith-database-schema/types/CombatTechnique_Close";
-import { RangedCombatTechnique } from "optolith-database-schema/types/CombatTechnique_Ranged";
-import { GetById } from "../helpers/getTypes.js";
+import type { GetInstanceById } from "../helpers/getTypes.js";
 /**
  * Get a JSON representation of the rules text for a close combat technique.
  */
-export declare const getCloseCombatTechniqueEntityDescription: import("../index.js").EntityDescriptionCreator<CloseCombatTechnique | undefined, {
-    getAttributeById: GetById.Static.Attribute;
+export declare const getCloseCombatTechniqueEntityDescription: import("../creator.js").EntityDescriptionCreator<"CloseCombatTechnique", {
+    getInstanceById: GetInstanceById<"Publication" | "Attribute">;
 }, import("../index.js").EntityDescription>;
 /**
  * Get a JSON representation of the rules text for a ranged combat technique.
  */
-export declare const getRangedCombatTechniqueEntityDescription: import("../index.js").EntityDescriptionCreator<RangedCombatTechnique | undefined, {
-    getAttributeById: GetById.Static.Attribute;
+export declare const getRangedCombatTechniqueEntityDescription: import("../creator.js").EntityDescriptionCreator<"RangedCombatTechnique", {
+    getInstanceById: GetInstanceById<"Publication" | "Attribute">;
 }, import("../index.js").EntityDescription>;

package/lib/entities/combatTechnique.js

@@ -1,10 +1,10 @@
 import { mapNullable } from "@optolith/helpers/nullable";
-import { createEntityDescriptionCreator } from "../index.js";
-import { createImprovementCost } from "./partial/rated/improvementCost.js";
+import { createEntityDescriptionCreator } from "../creator.js";
+import { renderImprovementCost } from "./partial/rated/improvementCost.js";
 /**
  * Get a JSON representation of the rules text for a close combat technique.
  */
-export const getCloseCombatTechniqueEntityDescription = createEntityDescriptionCreator(({ getAttributeById }, { translate, translateMap }, entry) => {
+export const getCloseCombatTechniqueEntityDescription = createEntityDescriptionCreator(({ getInstanceById }, { translate, translateMap }, { content: entry }) => {
     const translation = translateMap(entry.translations);
     if (translation === undefined) {
         return undefined;
@@ -13,26 +13,31 @@ export const getCloseCombatTechniqueEntityDescription = createEntityDescriptionC
         title: translation.name,
         className: "combat-technique close-combat-technique",
         body: [
-            mapNullable(translation.special, (value) => ({
-                label: translate("Special"),
-                value,
-            })),
             {
-                label: translate("Primary Attribute"),
-                value: entry.primary_attribute
-                    .map((attr) => translateMap(getAttributeById(attr.id.attribute)?.translations)
-                    ?.name)
-                    .join("/"),
+                type: "definitionList",
+                items: [
+                    mapNullable(translation.special, value => ({
+                        label: translate("Special"),
+                        value,
+                    })),
+                    {
+                        label: translate("Primary Attribute"),
+                        value: entry.primary_attribute
+                            .map(attrId => translateMap(getInstanceById("Attribute", attrId)?.translations)?.name)
+                            .join("/"),
+                    },
+                    renderImprovementCost(entry.improvement_cost).run({ translate }),
+                ],
             },
-            createImprovementCost(translate, entry.improvement_cost),
         ],
+        errata: translation.errata,
         references: entry.src,
     };
 });
 /**
  * Get a JSON representation of the rules text for a ranged combat technique.
  */
-export const getRangedCombatTechniqueEntityDescription = createEntityDescriptionCreator(({ getAttributeById }, { translate, translateMap }, entry) => {
+export const getRangedCombatTechniqueEntityDescription = createEntityDescriptionCreator(({ getInstanceById }, { translate, translateMap }, { content: entry }) => {
     const translation = translateMap(entry.translations);
     if (translation === undefined) {
         return undefined;
@@ -41,19 +46,24 @@ export const getRangedCombatTechniqueEntityDescription = createEntityDescription
         title: translation.name,
         className: "combat-technique ranged-combat-technique",
         body: [
-            mapNullable(translation.special, (value) => ({
-                label: translate("Special"),
-                value,
-            })),
             {
-                label: translate("Primary Attribute"),
-                value: entry.primary_attribute
-                    .map((attr) => translateMap(getAttributeById(attr.id.attribute)?.translations)
-                    ?.name)
-                    .join("/"),
+                type: "definitionList",
+                items: [
+                    mapNullable(translation.special, value => ({
+                        label: translate("Special"),
+                        value,
+                    })),
+                    {
+                        label: translate("Primary Attribute"),
+                        value: entry.primary_attribute
+                            .map(attrId => translateMap(getInstanceById("Attribute", attrId)?.translations)?.name)
+                            .join("/"),
+                    },
+                    renderImprovementCost(entry.improvement_cost).run({ translate }),
+                ],
             },
-            createImprovementCost(translate, entry.improvement_cost),
         ],
+        errata: translation.errata,
         references: entry.src,
     };
 });

package/lib/entities/condition.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Get a JSON representation of the rules text for a condition.
+ */
+export declare const getConditionEntityDescription: import("../creator.js").EntityDescriptionCreator<"Condition", {
+    getInstanceById: import("../helpers/getTypes.js").GetInstanceById<"Publication">;
+}, import("../index.js").EntityDescription>;
+/**
+ * Get a JSON representation of the rules text for a meta condition.
+ */
+export declare const getMetaConditionEntityDescription: import("../creator.js").EntityDescriptionCreator<"MetaCondition", {
+    getInstanceById: import("../helpers/getTypes.js").GetInstanceById<"Publication">;
+}, import("../index.js").EntityDescription>;

package/lib/entities/condition.js

@@ -0,0 +1,63 @@
+import { createEntityDescriptionCreator } from "../creator.js";
+/**
+ * Get a JSON representation of the rules text for a condition.
+ */
+export const getConditionEntityDescription = createEntityDescriptionCreator((_, { translate, translateMap }, { content: entry }) => {
+    const translation = translateMap(entry.translations);
+    if (translation === undefined) {
+        return undefined;
+    }
+    return {
+        title: translation.name,
+        className: "condition",
+        body: [
+            translation.rules === undefined
+                ? undefined
+                : { type: "plain", text: translation.rules },
+            {
+                type: "definitionList",
+                items: [
+                    ...translation.effects.map((effect, index) => ({
+                        label: translate("Level {$level}", {
+                            level: index + 1,
+                        }),
+                        value: effect,
+                    })),
+                ],
+            },
+        ],
+        errata: translation.errata,
+        references: entry.src,
+    };
+});
+/**
+ * Get a JSON representation of the rules text for a meta condition.
+ */
+export const getMetaConditionEntityDescription = createEntityDescriptionCreator((_, { translate, translateMap }, { content: entry }) => {
+    const translation = translateMap(entry.translations);
+    if (translation === undefined) {
+        return undefined;
+    }
+    return {
+        title: translation.name,
+        className: "meta-condition",
+        body: [
+            translation.rules === undefined
+                ? undefined
+                : { type: "plain", text: translation.rules },
+            {
+                type: "definitionList",
+                items: [
+                    ...translation.effects.map((effect, index) => ({
+                        label: translate("Level {$level}", {
+                            level: index + 1,
+                        }),
+                        value: effect,
+                    })),
+                ],
+            },
+        ],
+        errata: translation.errata,
+        references: entry.src,
+    };
+});

package/lib/entities/culture.d.ts

@@ -0,0 +1,8 @@
+import type { GetAllChildInstancesForParent, GetInstanceById } from "../helpers/getTypes.js";
+/**
+ * Get a JSON representation of the rules text for a culture.
+ */
+export declare const getCultureEntityDescription: import("../creator.js").EntityDescriptionCreator<"Culture", {
+    getInstanceById: GetInstanceById<"Publication" | "Advantage" | "Disadvantage" | "Skill" | "Language" | "LanguageSpecialization" | "Script" | "SocialStatus" | "ProfessionVariant" | "MagicalTradition" | "BlessedTradition">;
+    getChildInstancesForInstanceId: GetAllChildInstancesForParent<"ProfessionVersion">;
+}, import("../index.js").EntityDescription>;

package/lib/entities/culture.js

@@ -0,0 +1,309 @@
+import { allSame } from "@elyukai/utils/array/filters";
+import { ensureNonEmpty, isNotEmpty } from "@elyukai/utils/array/nonEmpty";
+import { sumWith } from "@elyukai/utils/array/reductions";
+import { equal } from "@elyukai/utils/equality";
+import { identity, on } from "@elyukai/utils/function";
+import { isNotNullish, mapNullable } from "@elyukai/utils/nullable";
+import { Reader } from "@elyukai/utils/reader";
+import { sign } from "@elyukai/utils/string/number";
+import { assertExhaustive } from "@elyukai/utils/typeSafety";
+import { createEntityDescriptionCreator } from "../creator.js";
+import { renderCommonnessRatedAdvantagesOrDisadvantages, renderValueWithPossibleTranslation, } from "./partial/commonnessRatedAdvantagesAndDisadvantages.js";
+import { getProfessionName } from "./partial/professions.js";
+import { parensIf } from "./partial/rated/activatable/parensIf.js";
+import { calculateAdventurePointsFromImprovementCost } from "./partial/rated/improvementCost.js";
+import { translateR, } from "./partial/reader.js";
+import { MISSING_VALUE } from "./partial/unknown.js";
+const renderListOperation = (operation, list) => {
+    switch (operation.kind) {
+        case "Intersection":
+            return Reader.of(list.join(", "));
+        case "Difference":
+            return translateR("all but {$excludedProfessions :list type=conjunction}", { excludedProfessions: list });
+        default:
+            return assertExhaustive(operation);
+    }
+};
+const renderCommonProfessionConstraints = (constraints, renderConstraint) => Reader.asks(({ localeCompare }) => Reader.sequence(constraints.constraints.map(renderConstraint)).thenW(constraintValues => renderListOperation(constraints.operation, constraintValues.filter(isNotNullish).toSorted(localeCompare)))).thenW(identity);
+const renderCommonProfessionGroup = (label, constraints, renderConstraint) => translateR(label).thenW(translatedLabel => (constraints === undefined
+    ? Reader.of("—")
+    : renderCommonProfessionConstraints(constraints, renderConstraint)).map(translatedValue => ({
+    label: translatedLabel,
+    value: translatedValue,
+})));
+const renderRarity = (rarity) => {
+    if (rarity === undefined) {
+        return Reader.of(undefined);
+    }
+    switch (rarity.kind) {
+        case "Rare":
+            return translateR("rare");
+        case "VeryRare":
+            return translateR("very rare");
+        default:
+            return assertExhaustive(rarity);
+    }
+};
+const renderWeighted = (weightedVariants, getName) => {
+    if (weightedVariants === undefined) {
+        return Reader.of(undefined);
+    }
+    return Reader.asks(({ translate, localeCompare }) => {
+        const variants = ensureNonEmpty(weightedVariants.elements
+            .map(getName)
+            .filter(isNotNullish)
+            .toSorted(localeCompare));
+        if (variants === undefined) {
+            return undefined;
+        }
+        switch (weightedVariants.weight.kind) {
+            case "Mostly":
+                return translate("mostly {$variants :list type=conjunction}", {
+                    variants,
+                });
+            case "Only":
+                return translate("only {$variants :list type=conjunction}", {
+                    variants,
+                });
+            default:
+                return assertExhaustive(weightedVariants.weight);
+        }
+    });
+};
+const renderProfessionConstraint = (getChildInstancesForInstanceId, constraint) => Reader.asks(({ translateMap }) => getProfessionName(translateMap, getChildInstancesForInstanceId, constraint.id)).thenW(baseName => baseName === undefined
+    ? Reader.of(undefined)
+    : Reader.sequence([
+        renderRarity(constraint.rarity),
+        Reader.asks(({ translateMap, getInstanceById, }) => renderWeighted(constraint.weighted_variants, variantId => translateMap(getInstanceById("ProfessionVariant", variantId)
+            ?.translations)?.name.default)).thenW(identity),
+    ]).map(notes => baseName +
+        parensIf(ensureNonEmpty(notes.filter(isNotNullish))?.join("; "))));
+const renderTraditionConstraint = (getChildInstancesForInstanceId, entity, constraint) => Reader.asks(({ translateMap, getInstanceById }) => {
+    const translation = translateMap(getInstanceById(entity, constraint.id)?.translations);
+    return translation?.nameOfBlessedOnes ?? translation?.name;
+}).thenW(baseName => baseName === undefined
+    ? Reader.of(undefined)
+    : Reader.sequence([
+        renderRarity(constraint.rarity),
+        Reader.asks(({ translateMap }) => renderWeighted(constraint.weighted_professions, profId => getProfessionName(translateMap, getChildInstancesForInstanceId, profId))).thenW(identity),
+    ]).map(notes => baseName +
+        parensIf(ensureNonEmpty(notes.filter(isNotNullish))?.join("; "))));
+const renderCommonProfessions = (getChildInstancesForInstanceId, commonProfessions) => {
+    switch (commonProfessions.kind) {
+        case "Plain":
+            return renderCommonProfessionConstraints(commonProfessions.Plain, profId => Reader.asks(({ translateMap }) => getProfessionName(translateMap, getChildInstancesForInstanceId, profId)));
+        case "Grouped":
+            return renderCommonProfessionGroup("Mundane Professions", commonProfessions.Grouped.mundane, constraint => 
+            // switch (constraint.kind) {
+            //   case "Profession":
+            renderProfessionConstraint(getChildInstancesForInstanceId, constraint.Profession)).then(mundane => renderCommonProfessionGroup("Magic Professions", commonProfessions.Grouped.magic, constraint => {
+                switch (constraint.kind) {
+                    case "Profession":
+                        return renderProfessionConstraint(getChildInstancesForInstanceId, constraint.Profession);
+                    case "Tradition":
+                        return renderTraditionConstraint(getChildInstancesForInstanceId, "MagicalTradition", constraint.Tradition);
+                    case "MagicDilettante":
+                        return translateR("Magic Dilettante");
+                    default:
+                        return assertExhaustive(constraint);
+                }
+            }).then(magic => renderCommonProfessionGroup("Blessed Professions", commonProfessions.Grouped.blessed, constraint => renderTraditionConstraint(getChildInstancesForInstanceId, "BlessedTradition", constraint.Tradition)).map(blessed => [
+                {
+                    type: "definitionList",
+                    style: "nested",
+                    items: [mundane, magic, blessed],
+                },
+            ])));
+        default:
+            return assertExhaustive(commonProfessions);
+    }
+};
+const renderCommonSkills = (items) => Reader.asks(({ translate, translateMap, getInstanceById, localeCompare }) => items === undefined || !isNotEmpty(items)
+    ? translate("none")
+    : items
+        .map(itemId => translateMap(getInstanceById("Skill", itemId)?.translations)
+        ?.name)
+        .filter(isNotNullish)
+        .toSorted(localeCompare)
+        .join(", "));
+const renderCommonNames = (commonNames) => Reader.asks(({ localeCompare }) => {
+    const groups = [
+        ...(commonNames.first_name_groups ?? []),
+        ...(commonNames.last_name_groups ?? []),
+    ].map((group) => ({
+        label: group.label,
+        value: group.names
+            .map(name => name.name + parensIf(name.note))
+            .toSorted(localeCompare)
+            .join(", "),
+    }));
+    const specialRules = commonNames.naming_rules;
+    return [
+        mapNullable(ensureNonEmpty(groups), renderedGroups => ({
+            type: "definitionList",
+            style: "nested",
+            items: renderedGroups,
+        })),
+        mapNullable(specialRules, rules => ({
+            type: "plain",
+            text: rules,
+        })),
+    ];
+});
+const renderCulturalPackage = (items) => Reader.asks(({ translate, translateMap, getInstanceById, localeCompare }) => {
+    if (!isNotEmpty(items)) {
+        return { text: translate("none"), apValue: 0 };
+    }
+    const processedItems = items.map((item) => {
+        const instance = getInstanceById("Skill", item.id);
+        const instanceTranslation = translateMap(instance?.translations);
+        if (instance === undefined || instanceTranslation === undefined) {
+            return [MISSING_VALUE, 0];
+        }
+        return [
+            `${instanceTranslation.name ?? MISSING_VALUE} ${sign(item.points)}`,
+            calculateAdventurePointsFromImprovementCost(instance.improvement_cost, [1, item.points]),
+        ];
+    });
+    return {
+        text: processedItems
+            .map(([text]) => text)
+            .toSorted(localeCompare)
+            .join(", "),
+        apValue: sumWith(processedItems, ([, apValue]) => apValue),
+    };
+});
+/**
+ * Get a JSON representation of the rules text for a culture.
+ */
+export const getCultureEntityDescription = createEntityDescriptionCreator(({ getInstanceById, getChildInstancesForInstanceId }, { translate, translateMap, compare: localeCompare, join: localeJoin }, { content: entry }) => {
+    const translation = translateMap(entry.translations);
+    if (translation === undefined) {
+        return undefined;
+    }
+    const env = {
+        translate,
+        translateMap,
+        localeCompare,
+        getInstanceById,
+    };
+    const { text: culturePackageText, apValue: culturalPackageApValue } = renderCulturalPackage(entry.cultural_package).run(env);
+    return {
+        title: translation.name,
+        className: "culture",
+        body: [
+            {
+                type: "definitionList",
+                items: [
+                    {
+                        label: translate("Language"),
+                        value: localeJoin(entry.language
+                            .map(lang => {
+                            const language = getInstanceById("Language", lang.id);
+                            const languageTranslation = translateMap(language?.translations);
+                            if (language === undefined ||
+                                languageTranslation === undefined) {
+                                return MISSING_VALUE;
+                            }
+                            return (languageTranslation.name +
+                                parensIf([
+                                    translateMap(language.customSpecializations?.translations)?.description,
+                                    ...(lang.specializations?.map(specId => translateMap(getInstanceById("LanguageSpecialization", specId)?.translations)?.name) ?? []),
+                                ]
+                                    .filter(isNotNullish)
+                                    .toSorted(localeCompare)
+                                    .join(", ")));
+                        })
+                            .toSorted(localeCompare), "disjunction"),
+                    },
+                    {
+                        label: translate("Script"),
+                        value: entry.script === undefined
+                            ? translate("none")
+                            : (() => {
+                                const processedScripts = entry.script.map((scriptId) => {
+                                    const script = getInstanceById("Script", scriptId);
+                                    const scriptTranslation = translateMap(script?.translations);
+                                    if (script === undefined ||
+                                        scriptTranslation === undefined) {
+                                        return [MISSING_VALUE, 0];
+                                    }
+                                    return [scriptTranslation.name, script.ap_value ?? 0];
+                                });
+                                if (!isNotEmpty(processedScripts)) {
+                                    return translate("none");
+                                }
+                                if (allSame(processedScripts, on(([, apValue]) => apValue, equal))) {
+                                    return (localeJoin(processedScripts
+                                        .map(([name]) => name)
+                                        .toSorted(localeCompare), "disjunction") +
+                                        parensIf(translate("{$value} AP", {
+                                            value: processedScripts[0][1],
+                                        })));
+                                }
+                                else {
+                                    return localeJoin(processedScripts
+                                        .map(([name, apValue]) => name +
+                                        parensIf(translate("{$value} AP", {
+                                            value: apValue,
+                                        })))
+                                        .toSorted(localeCompare), "disjunction");
+                                }
+                            })(),
+                    },
+                    {
+                        label: translate("Area Knowledge"),
+                        value: translation.area_knowledge.description +
+                            (translation.area_knowledge.examples === undefined
+                                ? ""
+                                : parensIf(translate("for example, {$examples}", {
+                                    examples: translation.area_knowledge.examples
+                                        .map(example => example.area)
+                                        .join(", "),
+                                }))),
+                    },
+                    {
+                        label: translate("Social Status"),
+                        value: entry.social_status
+                            .map(status => translateMap(getInstanceById("SocialStatus", status)?.translations)?.name ?? MISSING_VALUE)
+                            .toSorted(localeCompare)
+                            .join(", "),
+                    },
+                    {
+                        label: translate("Common Professions"),
+                        value: renderCommonProfessions(getChildInstancesForInstanceId, entry.common_professions).run(env),
+                    },
+                    renderValueWithPossibleTranslation("Common Advantages", entry.common_advantages, values => renderCommonnessRatedAdvantagesOrDisadvantages("Advantage", values).run(env), translation.common_advantages).run(env),
+                    renderValueWithPossibleTranslation("Common Disadvantages", entry.common_disadvantages, values => renderCommonnessRatedAdvantagesOrDisadvantages("Disadvantage", values).run(env), translation.common_disadvantages).run(env),
+                    renderValueWithPossibleTranslation("Uncommon Advantages", entry.uncommon_advantages, values => renderCommonnessRatedAdvantagesOrDisadvantages("Advantage", values).run(env), translation.uncommon_advantages).run(env),
+                    renderValueWithPossibleTranslation("Uncommon Disadvantages", entry.uncommon_disadvantages, values => renderCommonnessRatedAdvantagesOrDisadvantages("Disadvantage", values).run(env), translation.uncommon_disadvantages).run(env),
+                    {
+                        label: translate("Common Skills"),
+                        value: renderCommonSkills(entry.common_skills).run(env),
+                    },
+                    {
+                        label: translate("Uncommon Skills"),
+                        value: renderCommonSkills(entry.uncommon_skills).run(env),
+                    },
+                    {
+                        label: translate("Common Names"),
+                        value: renderCommonNames(translation.common_names).run(env),
+                    },
+                ],
+            },
+            {
+                type: "labeled",
+                label: translate("Cultural Package {$cultureName}", {
+                    cultureName: translation.name,
+                }) +
+                    parensIf(translate("{$value} AP", { value: culturalPackageApValue })),
+                value: {
+                    type: "plain",
+                    text: culturePackageText,
+                },
+            },
+        ],
+        errata: translation.errata,
+        references: entry.src,
+    };
+});

package/lib/entities/curriculum.d.ts

@@ -0,0 +1,11 @@
+import type { GetAllChildInstancesForParent, GetAllInstances, GetInstanceById } from "../helpers/getTypes.js";
+import type { IdMap } from "../index.js";
+/**
+ * Get a JSON representation of the rules text for a curriculum.
+ */
+export declare const getCurriculumEntityDescription: import("../creator.js").EntityDescriptionCreator<"Curriculum", {
+    getInstanceById: GetInstanceById<"Publication" | "Skill" | "CloseCombatTechnique" | "RangedCombatTechnique" | "Guideline" | "Spell" | "Ritual" | "MagicalTradition" | "Property" | "Element">;
+    getAllInstances: GetAllInstances<"Profession">;
+    getChildInstancesForInstanceId: GetAllChildInstancesForParent<"LessonPackage" | "ProfessionVersion" | "ProfessionPackage">;
+    idMap: IdMap;
+}, import("../index.js").EntityDescription>;