@optolith/entity-descriptions 0.13.2 → 0.15.0

package/lib/entities/equipment.js

@@ -1,17 +1,21 @@
 import { ensureNonEmpty, isNotEmpty } from "@elyukai/utils/array/nonEmpty";
 import { on } from "@elyukai/utils/function";
 import { isNotNullish } from "@elyukai/utils/nullable";
+import { omitKeys, sortObjectKeysByIndex } from "@elyukai/utils/object";
 import { compareNumber } from "@elyukai/utils/ordering";
+import { Reader } from "@elyukai/utils/reader";
 import { romanize } from "@elyukai/utils/roman";
 import { sign } from "@elyukai/utils/string/number";
 import { assertExhaustive } from "@elyukai/utils/typeSafety";
 import { mapNullable } from "@optolith/helpers/nullable";
 import { createEntityDescriptionCreator } from "../creator.js";
 import { renderDice, renderDiceAndFlat } from "./partial/dice.js";
-import { attributedName, attributedNameFromInstance } from "./partial/markdown.js";
+import { attributedName, attributedNameFromInstance, attributedNameFromText, } from "./partial/markdown.js";
 import { additionFormatter, subtractionFormatter } from "./partial/mathOperation.js";
 import { parensIf } from "./partial/rated/activatable/parensIf.js";
+import { attributedCustomNameR, formatNumber, getInstanceByIdR, localeSortR, nameR, sequence, translateMapR, translateR, } from "./partial/reader.js";
 import { ResponsiveTextSize } from "./partial/responsiveText.js";
+import { adjustWeight, formatAdjustedWeight, formatArbitrarySilverthalers, formatArbitraryWeight, formatSilverthalers, } from "./partial/units/simple.js";
 import { formatTimeSpan } from "./partial/units/timeSpan.js";
 import { MISSING_VALUE, UNHANDLED_VALUE } from "./partial/unknown.js";
 /**
@@ -229,25 +233,22 @@ const renderRangedDamage = (translate) => (damage) => {
             return assertExhaustive(damage);
     }
 };
-const renderComplexity = (translate, complexity) => mapNullable(complexity, c => ({
-    label: translate("Complexity"),
-    value: (() => {
-        switch (c.kind) {
-            case "Primitive":
-                return translate("Primitive");
-            case "Simple":
-                return translate("Simple");
-            case "Complex":
-                return `${translate("Complex")} (${translate("{$value} AP", {
-                    value: c.Complex.ap_value,
-                })})`;
-            case "Various":
-                return translate("Various");
-            default:
-                return assertExhaustive(c);
-        }
-    })(),
-}));
+const renderComplexity = (complexity) => mapNullable(complexity, c => {
+    switch (c.kind) {
+        case "Primitive":
+            return translateR("Primitive");
+        case "Simple":
+            return translateR("Simple");
+        case "Complex":
+            return sequence `${translateR("Complex")} (${translateR("{$value} AP", {
+                value: c.Complex.ap_value.toFixed(),
+            })})`;
+        case "Various":
+            return translateR("Various");
+        default:
+            return assertExhaustive(c);
+    }
+}) ?? Reader.of("—");
 const renderBlessedTraditionRestriction = (translate, translateMap, localeJoin, getInstanceById, name, restriction) => {
     const getName = (traditionId) => translateMap(getInstanceById("BlessedTradition", traditionId)?.translations)?.name;
     if (restriction.isSanctifiedBy) {
@@ -335,103 +336,80 @@ const renderNote = (translate, translateMap, getInstanceById, localeJoin, melee_
         : renderMagicalTraditionRestriction(translate, translateMap, getInstanceById, localeJoin, name, restrictedTo.magicalTraditions),
     note,
 ].filter(isNotNullish))?.join("; ");
-const renderWeight = (translate, formatNumber, measurements, weight) => {
+const renderWeightLabel = (entityName) => {
+    if (entityName === "Jewelry") {
+        return translateR("Weight (Bronze/Silver/Gold)");
+    }
+    else {
+        return translateR("Weight");
+    }
+};
+const renderWeightValue = (weight) => {
+    if (weight === undefined) {
+        return Reader.of("—");
+    }
     if (typeof weight === "number") {
-        return {
-            label: translate("Weight"),
-            value: translate(".input {$value :number} {{{$value} pounds}}", {
-                value: weight * measurements.stonesMultiplier,
-            }),
-        };
+        return formatAdjustedWeight(weight);
     }
     else {
-        return {
-            label: translate("Weight (Bronze/Silver/Gold)"),
-            value: translate("{$value} pounds", {
-                value: [weight.bronze, weight.silver, weight.gold]
-                    .map(value => formatNumber(value * measurements.stonesMultiplier))
-                    .join("/"),
-            }),
-        };
+        return Reader.traverse([weight.bronze, weight.silver, weight.gold], adjustWeight).thenW(values => formatArbitraryWeight(values.join("/")));
     }
 };
-const renderCost = (translate, translateMap, formatNumber, cost) => {
+const renderCostLabel = (entityName) => {
+    if (entityName === "Jewelry") {
+        return translateR("Cost (Bronze/Silver/Gold)");
+    }
+    else if (entityName === "GemOrPreciousStone") {
+        return translateR("Cost/10 carats");
+    }
+    else {
+        return translateR("Cost");
+    }
+};
+const renderCost = (cost) => {
+    if (cost === undefined) {
+        return Reader.of("—");
+    }
     const renderBookCostVariant = (bookCostVariant) => {
         switch (bookCostVariant.kind) {
-            case "Definite": {
-                const translation = translateMap(bookCostVariant.Definite.translations);
-                return (renderCost(translate, translateMap, formatNumber, bookCostVariant.Definite.cost).value +
-                    parensIf(translation?.label));
-            }
-            case "Indefinite": {
-                const translation = translateMap(bookCostVariant.Indefinite.translations);
-                return (translation?.description ?? MISSING_VALUE) + parensIf(translation?.label);
-            }
+            case "Definite":
+                return translateMapR(bookCostVariant.Definite.translations).thenW(translation => renderCost(bookCostVariant.Definite.cost).map(value => value + parensIf(translation?.label)));
+            case "Indefinite":
+                return translateMapR(bookCostVariant.Indefinite.translations).map(translation => (translation?.description ?? MISSING_VALUE) + parensIf(translation?.label));
             default:
                 return assertExhaustive(bookCostVariant);
         }
     };
     if ("bronze" in cost) {
-        return {
-            label: translate("Cost (Bronze/Silver/Gold)"),
-            value: translate("{$value} silverthalers", {
-                value: [cost.bronze, cost.silver, cost.gold].map(formatNumber).join("/"),
-            }),
-        };
+        return Reader.traverse([cost.bronze, cost.silver, cost.gold], formatNumber).thenW(values => formatArbitrarySilverthalers(values.join("/")));
     }
     else {
-        return {
-            label: translate("Cost"),
-            value: (() => {
-                switch (cost.kind) {
-                    case "Free":
-                        return translate("free");
-                    case "Various":
-                        return translate("various");
-                    case "Invaluable":
-                        return translate("invaluable");
-                    case "Fixed": {
-                        const translation = translateMap(cost.Fixed.translations);
-                        const main = translate(".input {$value :number} {{{$value} silverthalers}}", {
-                            value: cost.Fixed.value,
-                        });
-                        if (translation?.wrap_in_text === undefined) {
-                            return main;
-                        }
-                        return `${UNHANDLED_VALUE} ${translate(".input {$value :number} {{{$value} silverthalers}}", {
-                            value: cost.Fixed.value,
-                        })}`;
-                    }
-                    case "Range":
-                        return translate(".input {$from :number} .input {$to :number} {{{$from}–{$to} silverthalers}}", {
-                            from: cost.Range.from,
-                            to: cost.Range.to,
-                        });
-                    case "Single":
-                        return renderBookCostVariant(cost.Single);
-                    case "Multiple":
-                        return cost.Multiple.map(renderBookCostVariant).join(", ");
-                    default:
-                        return assertExhaustive(cost);
-                }
-            })(),
-        };
+        switch (cost.kind) {
+            case "Free":
+                return translateR("free");
+            case "Various":
+                return translateR("various");
+            case "Invaluable":
+                return translateR("invaluable");
+            case "Fixed": {
+                return translateMapR(cost.Fixed.translations).thenW(translation => formatSilverthalers(cost.Fixed.value).thenW(main => translation?.wrap_in_text === undefined
+                    ? Reader.of(main)
+                    : sequence `${UNHANDLED_VALUE} ${main}`));
+            }
+            case "Range":
+                return translateR(".input {$from :number} .input {$to :number} {{{$from}–{$to} silverthalers}}", {
+                    from: cost.Range.from,
+                    to: cost.Range.to,
+                });
+            case "Single":
+                return renderBookCostVariant(cost.Single);
+            case "Multiple":
+                return Reader.traverse(cost.Multiple, renderBookCostVariant).map(list => list.join(", "));
+            default:
+                return assertExhaustive(cost);
+        }
     }
 };
-const renderArmorValues = (translate, translateMap, localeCompare, getInstanceById, idMap, values) => [
-    { label: translate("Protection"), value: values.protection.toFixed() },
-    { label: translate("Encumbrance"), value: values.encumbrance.toFixed() },
-    {
-        label: translate("Additional Penalties"),
-        value: values.has_additional_penalties
-            ? [idMap.DerivedCharacteristic.Movement, idMap.DerivedCharacteristic.Initiative]
-                .map(dcId => `${sign(-1)} ${translateMap(getInstanceById("DerivedCharacteristic", dcId)?.translations)
-                ?.abbreviation ?? MISSING_VALUE}`)
-                .toSorted(localeCompare)
-                .join(", ")
-            : "—",
-    },
-];
 const normalizeCombatValues = (entity) => {
     switch (entity.entity) {
         case "Weapon":
@@ -620,17 +598,261 @@ const renderBookRules = (translate, rules) => {
             return assertExhaustive(rules);
     }
 };
+const renderStructurePoints = (structurePoints) => structurePoints !== undefined && isNotEmpty(structurePoints)
+    ? structurePoints.length === 1
+        ? translateR(".input {$value :number} {{{$value} Structure Points}}", {
+            value: structurePoints[0].points,
+        })
+        : translateR("{$value} Structure Points", {
+            value: structurePoints.map(elem => elem.points).join("/"),
+        })
+    : Reader.of("—");
+const meleeWeaponColumns = {
+    name: translateR("Name"),
+    damagePoints: translateR("DP"),
+    primaryAttributeDamageThreshold: translateR("P+T"),
+    attackParryModifier: translateR("AT/PA Mod"),
+    reach: translateR("RE"),
+    weight: translateR("Weight"),
+    length: translateR("Length"),
+    cost: translateR("Cost"),
+    complexity: translateR("Complexity"),
+};
+const rangedWeaponColumns = {
+    name: translateR("Name"),
+    damagePoints: translateR("DP"),
+    reloadTime: translateR("RT"),
+    range: translateR("RA"),
+    ammunition: translateR("Ammunition"),
+    weight: translateR("Weight"),
+    length: translateR("Length"),
+    cost: translateR("Cost"),
+    complexity: translateR("Complexity"),
+};
+const armorColumns = {
+    name: translateR("Name"),
+    protection: translateR("PRO"),
+    encumbrance: translateR("ENC"),
+    additionalPenalties: translateR("Additional Penalties"),
+    weight: translateR("Weight"),
+    cost: translateR("Cost"),
+    complexity: translateR("Complexity"),
+};
+const createMeleeWeaponTableEntry = (name, entityName, instance, instanceTranslation, combatTechniqueId, use) => {
+    const combatTechnique = getInstanceByIdR("CloseCombatTechnique", combatTechniqueId);
+    const combatTechniqueName = nameR("CloseCombatTechnique", combatTechniqueId);
+    const attributedCombatTechniqueName = combatTechniqueName.map(ctName => ctName === undefined
+        ? MISSING_VALUE
+        : attributedNameFromText(ctName, "equipment-table", "CloseCombatTechnique", combatTechniqueId));
+    return {
+        category: {
+            label: attributedCombatTechniqueName,
+            value: combatTechniqueName.map(ctName => `1-${ctName ?? MISSING_VALUE}`),
+        },
+        labels: sortObjectKeysByIndex({
+            ...meleeWeaponColumns,
+            weight: renderWeightLabel(entityName),
+            cost: renderCostLabel(entityName),
+        }, Object.keys(meleeWeaponColumns)),
+        values: {
+            name: Reader.of(name),
+            damagePoints: Reader.asks(env => renderMeleeDamage(env.translate)(use.damage)),
+            primaryAttributeDamageThreshold: combatTechnique.thenW(ct => Reader.asks(env => renderPrimaryAttributeAndDamageThreshold(env.translateMap, env.getInstanceById, ct, use.damage_threshold))),
+            attackParryModifier: Reader.of(renderAttackParryModifier(use.attackModifier, use.parryModifier)),
+            reach: Reader.asks(env => renderReach(env.translateMap, env.localeJoin, env.getInstanceById, use.reach)),
+            weight: renderWeightValue(instance.weight),
+            length: Reader.asks(env => renderLength(env.translate, env.measurementAdjustments, use.length)),
+            cost: renderCost(instance.cost),
+            complexity: renderComplexity(instance.complexity),
+        },
+        additionalInformation: [
+            instanceTranslation.note === undefined
+                ? undefined
+                : {
+                    label: translateR("Note"),
+                    id: "note",
+                    value: Reader.of(instanceTranslation.note),
+                },
+            instanceTranslation.rules === undefined
+                ? undefined
+                : {
+                    label: translateR("Rules"),
+                    id: "rules",
+                    value: Reader.of(instanceTranslation.rules),
+                },
+            instanceTranslation.advantage === undefined
+                ? undefined
+                : {
+                    label: translateR("Weapon Advantage"),
+                    id: "advantage",
+                    value: Reader.of(instanceTranslation.advantage),
+                },
+            instanceTranslation.disadvantage === undefined
+                ? undefined
+                : {
+                    label: translateR("Weapon Disadvantage"),
+                    id: "disadvantage",
+                    value: Reader.of(instanceTranslation.disadvantage),
+                },
+        ],
+    };
+};
+const createRangedWeaponTableEntry = (name, entityName, instance, instanceTranslation, combatTechniqueId, use) => {
+    const combatTechniqueName = nameR("RangedCombatTechnique", combatTechniqueId);
+    const attributedCombatTechniqueName = combatTechniqueName.map(ctName => ctName === undefined
+        ? MISSING_VALUE
+        : attributedNameFromText(ctName, "equipment-table", "RangedCombatTechnique", combatTechniqueId));
+    return {
+        category: {
+            label: attributedCombatTechniqueName,
+            value: combatTechniqueName.map(ctName => `2-${ctName ?? MISSING_VALUE}`),
+        },
+        labels: sortObjectKeysByIndex({
+            ...rangedWeaponColumns,
+            weight: renderWeightLabel(entityName),
+            cost: renderCostLabel(entityName),
+        }, Object.keys(rangedWeaponColumns)),
+        values: {
+            name: Reader.of(name),
+            damagePoints: Reader.asks(env => renderRangedDamage(env.translate)(use.damage)),
+            reloadTime: Reader.asks(env => renderReloadTime(env.translate, env.translateMap, env.format, use.reload_time)),
+            range: Reader.of(renderRangeBrackets(use.range)),
+            ammunition: Reader.asks(env => renderAmmunition(env.translateMap, env.getInstanceById, use.ammunition)),
+            weight: renderWeightValue(instance.weight),
+            length: Reader.asks(env => renderLength(env.translate, env.measurementAdjustments, use.length)),
+            cost: renderCost(instance.cost),
+            complexity: renderComplexity(instance.complexity),
+        },
+        additionalInformation: [
+            {
+                label: translateR("Note"),
+                id: "note",
+                value: Reader.asks(env => renderNote(env.translate, env.translateMap, env.getInstanceById, env.localeJoin, undefined, instance.restrictedTo, name, instanceTranslation.note)),
+            },
+            {
+                label: translateR("Rules"),
+                id: "rules",
+                value: Reader.of(instanceTranslation.rules),
+            },
+            {
+                label: translateR("Weapon Advantage"),
+                id: "advantage",
+                value: Reader.of(instanceTranslation.advantage),
+            },
+            {
+                label: translateR("Weapon Disadvantage"),
+                id: "disadvantage",
+                value: Reader.of(instanceTranslation.disadvantage),
+            },
+        ],
+    };
+};
+const createArmorTableEntry = (name, entityName, instance, instanceTranslation, values) => ({
+    labels: sortObjectKeysByIndex({ ...armorColumns, weight: renderWeightLabel(entityName), cost: renderCostLabel(entityName) }, Object.keys(armorColumns)),
+    values: {
+        name: Reader.of(name),
+        protection: Reader.of(values.protection.toFixed()),
+        encumbrance: Reader.of(values.encumbrance.toFixed()),
+        additionalPenalties: values.has_additional_penalties
+            ? Reader.asks((env) => [
+                env.idMap.DerivedCharacteristic.Movement,
+                env.idMap.DerivedCharacteristic.Initiative,
+            ])
+                .thenW(dcIds => Reader.traverse(dcIds, id => attributedCustomNameR("equipment-table", t => t.abbreviation, "DerivedCharacteristic", id).map(dcName => `${sign(-1)} ${dcName ?? MISSING_VALUE}`)))
+                .thenW(localeSortR)
+                .map(names => names.join(", "))
+            : Reader.of("—"),
+        weight: renderWeightValue(instance.weight),
+        cost: renderCost(instance.cost),
+        complexity: renderComplexity(instance.complexity),
+    },
+    additionalInformation: [
+        {
+            label: translateR("Note"),
+            id: "note",
+            value: Reader.asks(env => renderNote(env.translate, env.translateMap, env.getInstanceById, env.localeJoin, undefined, instance.restrictedTo, name, instanceTranslation.note)),
+        },
+        {
+            label: translateR("Rules"),
+            id: "rules",
+            value: Reader.of(instanceTranslation.rules),
+        },
+        {
+            label: translateR("Armor Advantage"),
+            id: "advantage",
+            value: Reader.of(instanceTranslation.advantage),
+        },
+        {
+            label: translateR("Armor Disadvantage"),
+            id: "disadvantage",
+            value: Reader.of(instanceTranslation.disadvantage),
+        },
+    ],
+});
+const createGemOrPreciousStoneTableEntry = (name, instance, instanceTranslation) => ({
+    labels: {
+        name: translateR("Name"),
+        color: translateR("Color"),
+        cost: renderCostLabel("GemOrPreciousStone"),
+    },
+    values: {
+        name: Reader.of(name),
+        color: Reader.of(instanceTranslation?.color ?? "—"),
+        cost: renderCost(instance.cost),
+    },
+    additionalInformation: [
+        {
+            label: translateR("Note"),
+            id: "note",
+            value: Reader.asks(env => renderNote(env.translate, env.translateMap, env.getInstanceById, env.localeJoin, undefined, undefined, name, instanceTranslation?.note)),
+        },
+        {
+            label: translateR("Rules"),
+            id: "rules",
+            value: Reader.of(instanceTranslation?.rules),
+        },
+    ],
+});
+const allSimpleKeys = ["name", "weight", "structurePoints", "cost", "complexity"];
+const createSimpleTableEntry = (name, entityName, useKeys, instance, instanceTranslation) => ({
+    labels: omitKeys({
+        name: translateR("Name"),
+        weight: renderWeightLabel(entityName),
+        structurePoints: translateR("Structure Points"),
+        cost: renderCostLabel(entityName),
+        complexity: translateR("Complexity"),
+    }, ...allSimpleKeys.filter(key => !(key in useKeys))),
+    values: omitKeys({
+        name: Reader.of(name),
+        structurePoints: renderStructurePoints(instance.structure_points),
+        weight: renderWeightValue(instance.weight),
+        cost: renderCost(instance.cost),
+        complexity: renderComplexity(instance.complexity),
+    }, ...allSimpleKeys.filter(key => !(key in useKeys))),
+    additionalInformation: [
+        {
+            label: translateR("Note"),
+            id: "note",
+            value: Reader.asks(env => renderNote(env.translate, env.translateMap, env.getInstanceById, env.localeJoin, undefined, instance.restrictedTo, name, instanceTranslation?.note)),
+        },
+        {
+            label: translateR("Rules"),
+            id: "rules",
+            value: Reader.of(instanceTranslation?.rules),
+        },
+    ],
+});
 /**
  * Get a JSON representation of the rules text for equipment.
  */
-export const getEquipmentEntityDescription = createEntityDescriptionCreator(({ getInstanceById, idMap }, locale, entry) => {
-    const { translate, translateMap, format } = locale;
+export const getEquipmentEntityDescription = createEntityDescriptionCreator((env, locale, entry) => {
+    const { translate, translateMap } = locale;
+    const name = getEquipmentName(translate, translateMap, env.getInstanceById, entry);
     if (entry.entity === "Book") {
         const translation = translateMap(entry.content.translations);
         if (translation === undefined) {
             return undefined;
         }
-        const name = getEquipmentName(translate, translateMap, getInstanceById, entry);
         return {
             title: name,
             className: "equipment",
@@ -644,7 +866,7 @@ export const getEquipmentEntityDescription = createEntityDescriptionCreator(({ g
                         },
                         {
                             label: translate("Type"),
-                            value: renderBookTypes(translate, translateMap, locale.join, locale.compare, getInstanceById, entry.content.types),
+                            value: renderBookTypes(translate, translateMap, locale.join, locale.compare, env.getInstanceById, entry.content.types),
                         },
                         translation.language !== undefined || translation.script !== undefined
                             ? {
@@ -674,7 +896,10 @@ export const getEquipmentEntityDescription = createEntityDescriptionCreator(({ g
                                     }
                                 })(),
                             },
-                        mapNullable(entry.content.cost, cost => renderCost(translate, translateMap, locale.formatNumber, cost)),
+                        mapNullable(entry.content.cost, cost => ({
+                            label: translate("Cost"),
+                            value: renderCost(cost).run(env),
+                        })),
                         translation.note === undefined
                             ? undefined
                             : {
@@ -718,118 +943,197 @@ export const getEquipmentEntityDescription = createEntityDescriptionCreator(({ g
     }
     const baseItem = entry.content;
     const baseItemTranslation = translation;
-    const name = getEquipmentName(translate, translateMap, getInstanceById, entry);
     const combatValues = normalizeCombatValues(entry);
     const combatTranslation = translateMap(combatValues?.values.translations);
-    return {
+    const baseProperties = {
+        type: "tabular",
         title: name,
         className: "equipment",
-        body: [
-            ...(combatValues?.type === "Weapon"
-                ? Object.entries(combatValues.values.melee_uses ?? {}).map(([combatTechniqueId, use]) => renderMeleeWeapon(translate, translateMap, locale.join, getInstanceById, locale.measurementAdjustments, renderMeleeDamage(translate), combatTechniqueId, use))
-                : []),
-            ...(combatValues?.type === "Weapon"
-                ? Object.entries(combatValues.values.ranged_uses ?? {}).map(([combatTechniqueId, use]) => renderRangedWeapon(translate, translateMap, format, getInstanceById, locale.measurementAdjustments, renderRangedDamage(translate), combatTechniqueId, use))
-                : []),
-            {
-                type: "definitionList",
-                items: [
-                    renderComplexity(translate, baseItem.complexity),
-                    ...(combatValues?.type === "Armor"
-                        ? renderArmorValues(translate, translateMap, locale.compare, getInstanceById, idMap, combatValues.values)
-                        : []),
-                    mapNullable(baseItem.burning_time, burningTime => ({
-                        label: translate("Burning Time"),
-                        value: burningTime.kind === "Unlimited"
-                            ? translate("unlimited")
-                            : formatTimeSpan(translate, translateMap, format, ResponsiveTextSize.Full, burningTime.Limited.unit, burningTime.Limited.value),
-                    })),
-                    mapNullable(baseItemTranslation?.color, color => ({
-                        label: translate("Color"),
-                        value: color,
-                    })),
-                    baseItem.structure_points !== undefined && isNotEmpty(baseItem.structure_points)
-                        ? {
-                            label: translate("Structure Points"),
-                            value: baseItem.structure_points.length === 1
-                                ? translate(".input {$value :number} {{{$value} Structure Points}}", {
-                                    value: baseItem.structure_points[0].points,
-                                })
-                                : translate("{$value} Structure Points", {
-                                    value: baseItem.structure_points.map(elem => elem.points).join("/"),
-                                }),
-                        }
-                        : undefined,
-                    mapNullable(baseItem.weight, weight => renderWeight(translate, locale.formatNumber, locale.measurementAdjustments, weight)),
-                    mapNullable(baseItem.cost, cost => renderCost(translate, translateMap, locale.formatNumber, cost)),
-                    mapNullable(renderNote(translate, translateMap, getInstanceById, locale.join, combatValues?.type === "Weapon" ? combatValues.values.melee_uses : undefined, combatValues?.values.restrictedTo, name, baseItemTranslation?.note), note => ({
-                        label: translate("Note"),
-                        value: note,
-                    })),
-                    baseItemTranslation?.rules !== undefined
-                        ? {
-                            label: translate("Rules"),
-                            value: baseItemTranslation.rules,
-                        }
-                        : undefined,
-                    combatValues?.type === "Weapon" && combatTranslation?.advantage !== undefined
-                        ? {
-                            label: translate("Weapon Advantage"),
-                            value: combatTranslation.advantage,
-                        }
-                        : undefined,
-                    combatValues?.type === "Weapon" && combatTranslation?.disadvantage !== undefined
-                        ? {
-                            label: translate("Weapon Disadvantage"),
-                            value: combatTranslation.disadvantage,
-                        }
-                        : undefined,
-                    combatValues?.type === "Armor" && combatTranslation?.advantage !== undefined
-                        ? {
-                            label: translate("Armor Advantage"),
-                            value: combatTranslation.advantage,
-                        }
-                        : undefined,
-                    combatValues?.type === "Armor" && combatTranslation?.disadvantage !== undefined
-                        ? {
-                            label: translate("Armor Disadvantage"),
-                            value: combatTranslation.disadvantage,
-                        }
-                        : undefined,
-                    baseItemTranslation?.placeOfPublication !== undefined
-                        ? {
-                            label: translate("Place of Publication"),
-                            value: baseItemTranslation.placeOfPublication,
-                        }
-                        : undefined,
-                    baseItemTranslation?.topics !== undefined
-                        ? {
-                            label: translate("Topics"),
-                            value: baseItemTranslation.topics.toSorted(locale.compare).join(", "),
-                        }
-                        : undefined,
-                    baseItemTranslation?.appearance !== undefined
-                        ? {
-                            label: translate("Appearance"),
-                            value: baseItemTranslation.appearance,
-                        }
-                        : undefined,
-                    baseItemTranslation?.components !== undefined
-                        ? {
-                            label: translate("Components"),
-                            value: baseItemTranslation.components,
-                        }
-                        : undefined,
-                    baseItemTranslation?.use !== undefined
-                        ? {
-                            label: translate("Use"),
-                            value: baseItemTranslation.use,
-                        }
-                        : undefined,
-                ],
-            },
-        ],
         errata: baseItemTranslation?.errata,
         references: entry.content.src,
     };
+    return [
+        ...(baseItemTranslation !== undefined && combatValues?.type === "Weapon"
+            ? Object.entries(combatValues.values.melee_uses ?? {}).map(([combatTechniqueId, use]) => ({
+                ...baseProperties,
+                ...createMeleeWeaponTableEntry(name, entry.entity, baseItem, { ...combatTranslation, ...baseItemTranslation }, combatTechniqueId, use),
+            }))
+            : []),
+        ...(baseItemTranslation !== undefined && combatValues?.type === "Weapon"
+            ? Object.entries(combatValues.values.ranged_uses ?? {}).map(([combatTechniqueId, use]) => ({
+                ...baseProperties,
+                ...createRangedWeaponTableEntry(name, entry.entity, baseItem, { ...combatTranslation, ...baseItemTranslation }, combatTechniqueId, use),
+            }))
+            : []),
+        ...(baseItemTranslation !== undefined && combatValues?.type === "Armor"
+            ? [
+                {
+                    ...baseProperties,
+                    ...createArmorTableEntry(name, entry.entity, baseItem, { ...combatTranslation, ...baseItemTranslation }, combatValues.values),
+                },
+            ]
+            : []),
+        ...(entry.entity === "Weapon" || entry.entity === "Armor"
+            ? []
+            : entry.entity === "GemOrPreciousStone"
+                ? [
+                    {
+                        ...baseProperties,
+                        ...createGemOrPreciousStoneTableEntry(name, entry.content, translateMap(entry.content.translations)),
+                    },
+                ]
+                : entry.entity === "MusicalInstrument" ||
+                    entry.entity === "Animal" ||
+                    entry.entity === "AnimalCare" ||
+                    entry.entity === "Vehicle"
+                    ? [
+                        {
+                            ...baseProperties,
+                            ...createSimpleTableEntry(name, entry.entity, {
+                                name: null,
+                                weight: null,
+                                cost: null,
+                            }, baseItem, baseItemTranslation),
+                        },
+                    ]
+                    : [
+                        {
+                            ...baseProperties,
+                            ...createSimpleTableEntry(name, entry.entity, {
+                                name: null,
+                                weight: null,
+                                structurePoints: null,
+                                cost: null,
+                                complexity: null,
+                            }, baseItem, baseItemTranslation),
+                        },
+                    ]),
+        // {
+        //   title: name,
+        //   className: "equipment",
+        //   body: [
+        //     {
+        //       type: "definitionList",
+        //       items: [
+        //         renderComplexity(translate, baseItem.complexity),
+        //         mapNullable(baseItem.burning_time, burningTime => ({
+        //           label: translate("Burning Time"),
+        //           value:
+        //             burningTime.kind === "Unlimited"
+        //               ? translate("unlimited")
+        //               : formatTimeSpan(
+        //                   translate,
+        //                   translateMap,
+        //                   format,
+        //                   ResponsiveTextSize.Full,
+        //                   burningTime.Limited.unit,
+        //                   burningTime.Limited.value,
+        //                 ),
+        //         })),
+        //         mapNullable(baseItemTranslation?.color, color => ({
+        //           label: translate("Color"),
+        //           value: color,
+        //         })),
+        //         baseItem.structure_points !== undefined && isNotEmpty(baseItem.structure_points)
+        //           ? {
+        //               label: translate("Structure Points"),
+        //               value:
+        //                 baseItem.structure_points.length === 1
+        //                   ? translate(".input {$value :number} {{{$value} Structure Points}}", {
+        //                       value: baseItem.structure_points[0].points,
+        //                     })
+        //                   : translate("{$value} Structure Points", {
+        //                       value: baseItem.structure_points.map(elem => elem.points).join("/"),
+        //                     }),
+        //             }
+        //           : undefined,
+        //         mapNullable(baseItem.weight, weight =>
+        //           renderWeight(translate, locale.formatNumber, locale.measurementAdjustments, weight),
+        //         ),
+        //         mapNullable(baseItem.cost, cost =>
+        //           renderCost(translate, translateMap, locale.formatNumber, cost),
+        //         ),
+        //         mapNullable(
+        //           renderNote(
+        //             translate,
+        //             translateMap,
+        //             getInstanceById,
+        //             locale.join,
+        //             combatValues?.type === "Weapon" ? combatValues.values.melee_uses : undefined,
+        //             combatValues?.values.restrictedTo,
+        //             name,
+        //             baseItemTranslation?.note,
+        //           ),
+        //           note => ({
+        //             label: translate("Note"),
+        //             value: note,
+        //           }),
+        //         ),
+        //         baseItemTranslation?.rules !== undefined
+        //           ? {
+        //               label: translate("Rules"),
+        //               value: baseItemTranslation.rules,
+        //             }
+        //           : undefined,
+        //         combatValues?.type === "Weapon" && combatTranslation?.advantage !== undefined
+        //           ? {
+        //               label: translate("Weapon Advantage"),
+        //               value: combatTranslation.advantage,
+        //             }
+        //           : undefined,
+        //         combatValues?.type === "Weapon" && combatTranslation?.disadvantage !== undefined
+        //           ? {
+        //               label: translate("Weapon Disadvantage"),
+        //               value: combatTranslation.disadvantage,
+        //             }
+        //           : undefined,
+        //         combatValues?.type === "Armor" && combatTranslation?.advantage !== undefined
+        //           ? {
+        //               label: translate("Armor Advantage"),
+        //               value: combatTranslation.advantage,
+        //             }
+        //           : undefined,
+        //         combatValues?.type === "Armor" && combatTranslation?.disadvantage !== undefined
+        //           ? {
+        //               label: translate("Armor Disadvantage"),
+        //               value: combatTranslation.disadvantage,
+        //             }
+        //           : undefined,
+        //         baseItemTranslation?.placeOfPublication !== undefined
+        //           ? {
+        //               label: translate("Place of Publication"),
+        //               value: baseItemTranslation.placeOfPublication,
+        //             }
+        //           : undefined,
+        //         baseItemTranslation?.topics !== undefined
+        //           ? {
+        //               label: translate("Topics"),
+        //               value: baseItemTranslation.topics.toSorted(locale.compare).join(", "),
+        //             }
+        //           : undefined,
+        //         baseItemTranslation?.appearance !== undefined
+        //           ? {
+        //               label: translate("Appearance"),
+        //               value: baseItemTranslation.appearance,
+        //             }
+        //           : undefined,
+        //         baseItemTranslation?.components !== undefined
+        //           ? {
+        //               label: translate("Components"),
+        //               value: baseItemTranslation.components,
+        //             }
+        //           : undefined,
+        //         baseItemTranslation?.use !== undefined
+        //           ? {
+        //               label: translate("Use"),
+        //               value: baseItemTranslation.use,
+        //             }
+        //           : undefined,
+        //       ],
+        //     },
+        //   ] as (RawEntityDescriptionSection | undefined)[],
+        //   errata: baseItemTranslation?.errata,
+        //   references: entry.content.src,
+        // },
+    ];
 });