@optolith/entity-descriptions 0.2.0 → 0.3.1

package/lib/entities/equipmentPackage.js

@@ -0,0 +1,301 @@
+import { on } from "@elyukai/utils/function";
+import { assertExhaustive } from "@elyukai/utils/typeSafety";
+import { createEntityDescriptionCreator, } from "../creator.js";
+import { getEquipmentName } from "./equipment.js";
+const sumAtomicEquipmentCost = (acc, current) => {
+    if (typeof acc === "string") {
+        return acc;
+    }
+    if (typeof current === "string") {
+        return current;
+    }
+    if (Array.isArray(current)) {
+        if (Array.isArray(acc)) {
+            return [acc[0] + current[0], acc[1] + current[1]];
+        }
+        else {
+            return [acc + current[0], acc + current[1]];
+        }
+    }
+    else if (Array.isArray(acc)) {
+        return [acc[0] + current, acc[1] + current];
+    }
+    else {
+        return acc + current;
+    }
+};
+const sumAtomicEquipmentWeight = (acc, current) => {
+    if (Array.isArray(current)) {
+        if (Array.isArray(acc)) {
+            return [acc[0] + current[0], acc[1] + current[1]];
+        }
+        else {
+            return [acc + current[0], acc + current[1]];
+        }
+    }
+    else if (Array.isArray(acc)) {
+        return [acc[0] + current, acc[1] + current];
+    }
+    else {
+        return acc + current;
+    }
+};
+const rangeAtomicEquipmentCost = (acc, current) => {
+    if (typeof acc === "string") {
+        return acc;
+    }
+    if (typeof current === "string") {
+        return current;
+    }
+    const normAcc = typeof acc === "number" ? [acc, acc] : acc;
+    const normCurrent = typeof current === "number" ? [current, current] : current;
+    return [
+        Math.min(normAcc[0], normCurrent[0]),
+        Math.max(normAcc[1], normCurrent[1]),
+    ];
+};
+const getAtomicCost = (cost) => {
+    switch (cost.kind) {
+        case "Free":
+            return 0;
+        case "Various":
+            return "Various";
+        case "Invaluable":
+            return "Invaluable";
+        case "Fixed":
+            return cost.Fixed.value;
+        case "Range":
+            return [cost.Range.from, cost.Range.to];
+        default:
+            return assertExhaustive(cost);
+    }
+};
+const getAtomicEquipmentCost = (entry) => {
+    switch (entry.entity) {
+        case "AnimalCare":
+            switch (entry.content.type.kind) {
+                case "General":
+                    return getAtomicCost(entry.content.type.General.cost);
+                case "Feed":
+                    return entry.content.type.Feed.cost.PerWeek.value;
+                default:
+                    return assertExhaustive(entry.content.type);
+            }
+        case "Book": {
+            switch (entry.content.cost.kind) {
+                case "Single":
+                    switch (entry.content.cost.Single.kind) {
+                        case "Definite":
+                            return getAtomicCost(entry.content.cost.Single.Definite.cost);
+                        case "Indefinite":
+                            return "Various";
+                        default:
+                            return assertExhaustive(entry.content.cost.Single);
+                    }
+                case "Multiple":
+                    return (entry.content.cost.Multiple.reduce((acc, cost) => {
+                        if (typeof acc === "string") {
+                            return acc;
+                        }
+                        switch (cost.kind) {
+                            case "Definite":
+                                return acc === null
+                                    ? getAtomicCost(cost.Definite.cost)
+                                    : rangeAtomicEquipmentCost(acc, getAtomicCost(cost.Definite.cost));
+                            case "Indefinite":
+                                return "Various";
+                            default:
+                                return assertExhaustive(cost);
+                        }
+                    }, null) ?? 0);
+                default:
+                    return assertExhaustive(entry.content.cost);
+            }
+        }
+        case "Jewelry": {
+            const costs = [
+                entry.content.cost.bronze,
+                entry.content.cost.silver,
+                entry.content.cost.gold,
+            ];
+            return costs.map(getAtomicCost).reduce(rangeAtomicEquipmentCost);
+        }
+        case "Ammunition":
+        case "Animal":
+        case "Armor":
+        case "BandageOrRemedy":
+        case "CeremonialItem":
+        case "Clothes":
+        case "ClothingPackage":
+        case "Container":
+        case "EquipmentOfBlessedOnes":
+        case "GemOrPreciousStone":
+        case "IlluminationLightSource":
+        case "IlluminationRefillOrSupply":
+        case "Laboratory":
+        case "Liebesspielzeug":
+        case "LuxuryGood":
+        case "MagicalArtifact":
+        case "MusicalInstrument":
+        case "Newspaper":
+        case "OrienteeringAid":
+        case "RopeOrChain":
+        case "Stationery":
+        case "ThievesTool":
+        case "ToolOfTheTrade":
+        case "TravelGearOrTool":
+        case "Vehicle":
+        case "Weapon":
+        case "WeaponAccessory":
+            return getAtomicCost(entry.content.cost);
+        case "Elixir":
+            return [
+                entry.content.cost_per_ingredient_level,
+                entry.content.cost_per_ingredient_level * 6,
+            ];
+        case "Poison":
+            switch (entry.content.cost.kind) {
+                case "CannotBeExtracted":
+                case "None":
+                    return 0;
+                case "Constant":
+                    return entry.content.cost.Constant;
+                case "Indefinite":
+                    return "Various";
+                default:
+                    return assertExhaustive(entry.content.cost);
+            }
+        default:
+            return assertExhaustive(entry);
+    }
+};
+const getAtomicEquipmentWeight = (entry) => {
+    switch (entry.entity) {
+        case "Ammunition":
+        case "Animal":
+        case "ClothingPackage":
+        case "Elixir":
+        case "EquipmentOfBlessedOnes":
+        case "Newspaper":
+        case "Poison":
+            return 0;
+        case "AnimalCare":
+            switch (entry.content.type.kind) {
+                case "General":
+                    return entry.content.type.General.weight;
+                case "Feed":
+                    return 0;
+                default:
+                    return assertExhaustive(entry.content.type);
+            }
+        case "Jewelry": {
+            const values = Object.values(entry.content.weight);
+            return [Math.min(...values), Math.max(...values)];
+        }
+        case "Armor":
+        case "BandageOrRemedy":
+        case "Book":
+        case "CeremonialItem":
+        case "Clothes":
+        case "Container":
+        case "GemOrPreciousStone":
+        case "IlluminationLightSource":
+        case "IlluminationRefillOrSupply":
+        case "Laboratory":
+        case "Liebesspielzeug":
+        case "LuxuryGood":
+        case "MagicalArtifact":
+        case "MusicalInstrument":
+        case "OrienteeringAid":
+        case "RopeOrChain":
+        case "Stationery":
+        case "ThievesTool":
+        case "ToolOfTheTrade":
+        case "TravelGearOrTool":
+        case "Vehicle":
+        case "Weapon":
+        case "WeaponAccessory":
+            return entry.content.weight ?? 0;
+        default:
+            return assertExhaustive(entry);
+    }
+};
+const renderAtomicCost = (translate, cost) => {
+    if (typeof cost === "number") {
+        return translate(".input {$value :number} {{{$value} silverthalers}}", {
+            value: cost,
+        });
+    }
+    else if (typeof cost === "string") {
+        switch (cost) {
+            case "Various":
+                return translate("various");
+            case "Invaluable":
+                return translate("invaluable");
+            default:
+                return assertExhaustive(cost);
+        }
+    }
+    else {
+        return translate(".input {$from :number} .input {$to :number} {{{$from}–{$to} silverthalers}}", {
+            from: cost[0],
+            to: cost[1],
+        });
+    }
+};
+const renderAtomicWeight = (translate, measurements, cost) => {
+    if (typeof cost === "number") {
+        return translate(".input {$value :number} {{{$value} pounds}}", {
+            value: measurements.stonesMultiplier * cost,
+        });
+    }
+    else {
+        return translate(".input {$from :number} .input {$to :number} {{{$from}–{$to} pounds}}", {
+            from: measurements.stonesMultiplier * cost[0],
+            to: measurements.stonesMultiplier * cost[1],
+        });
+    }
+};
+/**
+ * Get a JSON representation of the rules text for an equipment package.
+ */
+export const getEquipmentPackageEntityDescription = createEntityDescriptionCreator(({ getInstanceById }, locale, { content }) => {
+    const { translate, translateMap } = locale;
+    const translation = translateMap(content.translations);
+    if (translation === undefined) {
+        return undefined;
+    }
+    const actualItems = content.items
+        ?.map(item => ({
+        ...item,
+        content: { entity: item.id.kind, content: getInstanceById(item.id) },
+    }))
+        .filter((item) => item.content !== undefined) ?? [];
+    return {
+        title: translation.name,
+        className: "equipment-package",
+        body: [
+            {
+                type: "table",
+                header: [translation.name, translate("Weight"), translate("Cost")],
+                rows: actualItems
+                    .map((item) => [
+                    getEquipmentName(translate, translateMap, getInstanceById, item.content),
+                    renderAtomicWeight(translate, locale.measurementAdjustments, getAtomicEquipmentWeight(item.content)),
+                    renderAtomicCost(translate, getAtomicEquipmentCost(item.content)),
+                ])
+                    .toSorted(on(item => item[0], locale.compare)),
+                footer: [
+                    translate("Total"),
+                    renderAtomicWeight(translate, locale.measurementAdjustments, actualItems
+                        .map(item => getAtomicEquipmentWeight(item.content))
+                        .reduce(sumAtomicEquipmentWeight, 0)),
+                    renderAtomicCost(translate, actualItems
+                        .map(item => getAtomicEquipmentCost(item.content))
+                        .reduce(sumAtomicEquipmentCost, 0)),
+                ],
+            },
+        ],
+        references: content.src,
+    };
+});

package/lib/entities/experienceLevel.d.ts

@@ -1,5 +1,6 @@
-import { ExperienceLevel } from "optolith-database-schema/types/ExperienceLevel";
 /**
  * Get a JSON representation of the rules text for an experience level.
  */
-export declare const getExperienceLevelEntityDescription: import("../index.js").EntityDescriptionCreator<ExperienceLevel | undefined, Record<string, never>, import("../index.js").EntityDescription>;
+export declare const getExperienceLevelEntityDescription: import("../creator.js").EntityDescriptionCreator<"ExperienceLevel", {
+    getInstanceById: import("../helpers/getTypes.js").GetInstanceById<"Publication">;
+}, import("../index.js").EntityDescription>;

package/lib/entities/experienceLevel.js

@@ -1,8 +1,8 @@
-import { createEntityDescriptionCreator } from "../index.js";
+import { createEntityDescriptionCreator } from "../creator.js";
 /**
  * Get a JSON representation of the rules text for an experience level.
  */
-export const getExperienceLevelEntityDescription = createEntityDescriptionCreator((_, { translate, translateMap }, entry) => {
+export const getExperienceLevelEntityDescription = createEntityDescriptionCreator((_, { translate, translateMap }, { content: entry }) => {
     const translation = translateMap(entry.translations);
     if (translation === undefined) {
         return undefined;
@@ -12,32 +12,37 @@ export const getExperienceLevelEntityDescription = createEntityDescriptionCreato
         className: "experience-level",
         body: [
             {
-                label: translate("Adventure Points"),
-                value: entry.adventure_points,
-            },
-            {
-                label: translate("Maximum Attribute Value"),
-                value: entry.max_attribute_value,
-            },
-            {
-                label: translate("Maximum Skill Value"),
-                value: entry.max_skill_rating,
-            },
-            {
-                label: translate("Maximum Combat Technique"),
-                value: entry.max_combat_technique_rating,
-            },
-            {
-                label: translate("Maximum Attribute Total"),
-                value: entry.max_attribute_total,
-            },
-            {
-                label: translate("Number of Spells/Liturgical Chants"),
-                value: entry.max_number_of_spells_liturgical_chants,
-            },
-            {
-                label: translate("Number from other Traditions"),
-                value: entry.max_number_of_unfamiliar_spells,
+                type: "definitionList",
+                items: [
+                    {
+                        label: translate("Adventure Points"),
+                        value: entry.adventure_points.toString(),
+                    },
+                    {
+                        label: translate("Maximum Attribute Value"),
+                        value: entry.max_attribute_value.toString(),
+                    },
+                    {
+                        label: translate("Maximum Skill Value"),
+                        value: entry.max_skill_rating.toString(),
+                    },
+                    {
+                        label: translate("Maximum Combat Technique"),
+                        value: entry.max_combat_technique_rating.toString(),
+                    },
+                    {
+                        label: translate("Maximum Attribute Total"),
+                        value: entry.max_attribute_total.toString(),
+                    },
+                    {
+                        label: translate("Number of Spells/Liturgical Chants"),
+                        value: entry.max_number_of_spells_liturgical_chants.toString(),
+                    },
+                    {
+                        label: translate("Number from other Traditions"),
+                        value: entry.max_number_of_unfamiliar_spells.toString(),
+                    },
+                ],
             },
         ],
     };

package/lib/entities/focusRule.d.ts

@@ -1,8 +1,7 @@
-import { FocusRule } from "optolith-database-schema/types/rule/FocusRule";
-import { GetById } from "../helpers/getTypes.js";
+import type { GetInstanceById } from "../helpers/getTypes.js";
 /**
  * Get a JSON representation of the rules text for a focus rule.
  */
-export declare const getFocusRuleEntityDescription: import("../index.js").EntityDescriptionCreator<FocusRule | undefined, {
-    getSubjectById: GetById.Static.Subject;
+export declare const getFocusRuleEntityDescription: import("../creator.js").EntityDescriptionCreator<"FocusRule", {
+    getInstanceById: GetInstanceById<"Publication" | "Subject">;
 }, import("../index.js").EntityDescription>;

package/lib/entities/focusRule.js

@@ -1,18 +1,26 @@
 import { romanize } from "@optolith/helpers/roman";
-import { createEntityDescriptionCreator } from "../index.js";
+import { createEntityDescriptionCreator } from "../creator.js";
 /**
  * Get a JSON representation of the rules text for a focus rule.
  */
-export const getFocusRuleEntityDescription = createEntityDescriptionCreator(({ getSubjectById }, { translateMap }, entry) => {
+export const getFocusRuleEntityDescription = createEntityDescriptionCreator(({ getInstanceById }, { translate, translateMap }, { content: entry }) => {
     const translation = translateMap(entry.translations);
-    if (translation === undefined) {
+    const topicTranslation = translateMap(getInstanceById("Subject", entry.subject)?.translations);
+    if (translation === undefined || topicTranslation === undefined) {
         return undefined;
     }
     return {
         title: `${translation.name} (${romanize(entry.level)})`,
-        subtitle: translateMap(getSubjectById(entry.subject.id.subject)?.translations)?.name,
+        subtitle: topicTranslation.name,
         className: "focus-rule",
-        body: [{ value: translation.description }],
+        body: [
+            {
+                type: "plain",
+                text: translate("The following rule is a Level {$level} focus rule for the topic {$topic}.", { level: romanize(entry.level), topic: topicTranslation.name }),
+            },
+            { type: "plain", text: translation.description },
+        ],
+        errata: translation.errata,
         references: entry.src,
     };
 });

package/lib/entities/influence.d.ts

@@ -0,0 +1,7 @@
+import type { GetInstanceById } from "../helpers/getTypes.js";
+/**
+ * Get a JSON representation of the rules text for an influence.
+ */
+export declare const getInfluenceEntityDescription: import("../creator.js").EntityDescriptionCreator<"Influence", {
+    getInstanceById: GetInstanceById<"Publication" | "Influence">;
+}, import("../index.js").EntityDescription>;

package/lib/entities/influence.js

@@ -0,0 +1,35 @@
+import { createEntityDescriptionCreator } from "../creator.js";
+import { printInfluencePrerequisites } from "./partial/prerequisites/index.js";
+/**
+ * Get a JSON representation of the rules text for an influence.
+ */
+export const getInfluenceEntityDescription = createEntityDescriptionCreator(({ getInstanceById }, locale, { content: entry }) => {
+    const { translate, translateMap } = locale;
+    const translation = translateMap(entry.translations);
+    if (translation === undefined) {
+        return undefined;
+    }
+    return {
+        title: translation.name,
+        className: "influence",
+        body: [
+            {
+                type: "definitionList",
+                items: [
+                    ...(translation.effects?.map(effect => ({
+                        label: effect.label,
+                        value: effect.text,
+                    })) ?? []),
+                    entry.prerequisites === undefined
+                        ? undefined
+                        : {
+                            label: translate("Prerequisites"),
+                            value: printInfluencePrerequisites(getInstanceById, locale, entry.prerequisites),
+                        },
+                ],
+            },
+        ],
+        errata: translation.errata,
+        references: entry.src,
+    };
+});

package/lib/entities/liturgicalChant.d.ts

@@ -1,35 +1,22 @@
-import { Blessing } from "optolith-database-schema/types/Blessing";
-import { Ceremony } from "optolith-database-schema/types/Ceremony";
-import { DerivedCharacteristic } from "optolith-database-schema/types/DerivedCharacteristic";
-import { LiturgicalChant } from "optolith-database-schema/types/LiturgicalChant";
-import { GetById } from "../helpers/getTypes.js";
+import type { GetInstanceById } from "../helpers/getTypes.js";
+import { type IdMap } from "../index.js";
 /**
  * Get a JSON representation of the rules text for a blessing.
  */
-export declare const getBlessingEntityDescription: import("../index.js").EntityDescriptionCreator<Blessing | undefined, {
-    getTargetCategoryById: GetById.Static.TargetCategory;
+export declare const getBlessingEntityDescription: import("../creator.js").EntityDescriptionCreator<"Blessing", {
+    getInstanceById: GetInstanceById<"Publication" | "TargetCategory">;
 }, import("../index.js").EntityDescription>;
 /**
  * Get a JSON representation of the rules text for a liturgical chant.
  */
-export declare const getLiturgicalChantEntityDescription: import("../index.js").EntityDescriptionCreator<LiturgicalChant | undefined, {
-    getAttributeById: GetById.Static.Attribute;
-    getSpirit: () => DerivedCharacteristic | undefined;
-    getToughness: () => DerivedCharacteristic | undefined;
-    getSkillModificationLevelById: GetById.Static.SkillModificationLevel;
-    getTargetCategoryById: GetById.Static.TargetCategory;
-    getBlessedTraditionById: GetById.Static.BlessedTradition;
-    getAspectById: GetById.Static.Aspect;
+export declare const getLiturgicalChantEntityDescription: import("../creator.js").EntityDescriptionCreator<"LiturgicalChant", {
+    getInstanceById: GetInstanceById<"Publication" | "Attribute" | "SkillModificationLevel" | "TargetCategory" | "Aspect" | "BlessedTradition" | "DerivedCharacteristic">;
+    idMap: IdMap;
 }, import("../index.js").EntityDescription>;
 /**
  * Get a JSON representation of the rules text for a ceremony.
  */
-export declare const getCeremonyEntityDescription: import("../index.js").EntityDescriptionCreator<Ceremony | undefined, {
-    getAttributeById: GetById.Static.Attribute;
-    getSpirit: () => DerivedCharacteristic | undefined;
-    getToughness: () => DerivedCharacteristic | undefined;
-    getSkillModificationLevelById: GetById.Static.SkillModificationLevel;
-    getTargetCategoryById: GetById.Static.TargetCategory;
-    getBlessedTraditionById: GetById.Static.BlessedTradition;
-    getAspectById: GetById.Static.Aspect;
+export declare const getCeremonyEntityDescription: import("../creator.js").EntityDescriptionCreator<"Ceremony", {
+    getInstanceById: GetInstanceById<"Publication" | "Attribute" | "SkillModificationLevel" | "TargetCategory" | "Aspect" | "BlessedTradition" | "DerivedCharacteristic">;
+    idMap: IdMap;
 }, import("../index.js").EntityDescription>;