@optolith/entity-descriptions 0.0.1

package/lib/entities/partial/rated/activatable/targetCategory.js

@@ -0,0 +1,36 @@
+import { mapNullable } from "@optolith/helpers/nullable";
+import { assertExhaustive } from "@optolith/helpers/typeSafety";
+import { MISSING_VALUE } from "../../unknown.js";
+import { appendInParens } from "./parensIf.js";
+/**
+ * Get the text for the target category.
+ */
+export const getTextForTargetCategory = (deps, values) => ({
+    label: deps.translate("Target Category"),
+    value: values.length === 0
+        ? deps.translate("all")
+        : values
+            .map(({ id, translations }) => {
+            const mainName = (() => {
+                switch (id.tag) {
+                    case "Self":
+                        return deps.translate("Self");
+                    case "Zone":
+                        return deps.translate("Zone");
+                    case "LiturgicalChantsAndCeremonies":
+                        return deps.translate("Liturgical Chants and Ceremonies");
+                    case "Cantrips":
+                        return deps.translate("Cantrips");
+                    case "Predefined": {
+                        const numericId = id.predefined.id.target_category;
+                        const specificTargetCategory = deps.getTargetCategoryById(numericId);
+                        return (mapNullable(deps.translateMap(specificTargetCategory?.translations), (translation) => translation.name) ?? MISSING_VALUE);
+                    }
+                    default:
+                        return assertExhaustive(id);
+                }
+            })();
+            return appendInParens(mainName, deps.translateMap(translations)?.note);
+        })
+            .join(", "),
+});

package/lib/entities/partial/rated/activatable/units.d.ts

@@ -0,0 +1,13 @@
+import { Translate } from "../../../../helpers/translate.js";
+import { ResponsiveTextSize } from "../../responsiveText.js";
+import { Entity } from "./entity.js";
+type TimeSpanUnit = "Seconds" | "Minutes" | "Hours" | "Days" | "Weeks" | "Months" | "Years" | "Centuries" | "Actions" | "CombatRounds" | "SeductionActions" | "Rounds";
+/**
+ * Returns the text for a time span unit.
+ */
+export declare const formatTimeSpan: (translate: Translate, responsiveTextSize: ResponsiveTextSize, unit: TimeSpanUnit, value: number | string) => string;
+/**
+ * Returns the text for a cost unit that is based on the entity type.
+ */
+export declare const formatCost: (translate: Translate, entity: Entity, value: number | string) => string;
+export {};

package/lib/entities/partial/rated/activatable/units.js

@@ -0,0 +1,53 @@
+import { assertExhaustive } from "@optolith/helpers/typeSafety";
+import { responsive } from "../../responsiveText.js";
+import { Entity } from "./entity.js";
+/**
+ * Returns the text for a time span unit.
+ */
+export const formatTimeSpan = (translate, responsiveTextSize, unit, value) => {
+    switch (unit) {
+        case "Seconds":
+            return responsive(responsiveTextSize, () => translate("{0} seconds", value), () => translate("{0} s", value));
+        case "Minutes":
+            return responsive(responsiveTextSize, () => translate("{0} minutes", value), () => translate("{0} min", value));
+        case "Hours":
+            return responsive(responsiveTextSize, () => translate("{0} hours", value), () => translate("{0} h", value));
+        case "Days":
+            return responsive(responsiveTextSize, () => translate("{0} days", value), () => translate("{0} d", value));
+        case "Weeks":
+            return responsive(responsiveTextSize, () => translate("{0} weeks", value), () => translate("{0} wks.", value));
+        case "Months":
+            return responsive(responsiveTextSize, () => translate("{0} months", value), () => translate("{0} mos.", value));
+        case "Years":
+            return responsive(responsiveTextSize, () => translate("{0} years", value), () => translate("{0} yrs.", value));
+        case "Centuries":
+            return responsive(responsiveTextSize, () => translate("{0} centuries", value), () => translate("{0} cent.", value));
+        case "Actions":
+            return responsive(responsiveTextSize, () => translate("{0} actions", value), () => translate("{0} act", value));
+        case "CombatRounds":
+            return responsive(responsiveTextSize, () => translate("{0} combat rounds", value), () => translate("{0} CR", value));
+        case "SeductionActions":
+            return responsive(responsiveTextSize, () => translate("{0} seduction actions", value), () => translate("{0} SA", value));
+        case "Rounds":
+            return responsive(responsiveTextSize, () => translate("{0} rounds", value), () => translate("{0} rnds", value));
+        default:
+            return assertExhaustive(unit);
+    }
+};
+/**
+ * Returns the text for a cost unit that is based on the entity type.
+ */
+export const formatCost = (translate, entity, value) => {
+    switch (entity) {
+        case Entity.Cantrip:
+        case Entity.Spell:
+        case Entity.Ritual:
+            return translate("{0} AE", value);
+        case Entity.Blessing:
+        case Entity.LiturgicalChant:
+        case Entity.Ceremony:
+            return translate("{0} KP", value);
+        default:
+            return assertExhaustive(entity);
+    }
+};

package/lib/entities/partial/rated/improvementCost.d.ts

@@ -0,0 +1,7 @@
+import { ImprovementCost as RawImprovementCost } from "optolith-database-schema/types/_ImprovementCost";
+import { Translate } from "../../../helpers/translate.js";
+import { LibraryEntryContent } from "../../../libraryEntry.js";
+/**
+ * Returns the improvement cost as an inline library property.
+ */
+export declare const createImprovementCost: (translate: Translate, improvementCost: RawImprovementCost) => LibraryEntryContent;

package/lib/entities/partial/rated/improvementCost.js

@@ -0,0 +1,7 @@
+/**
+ * Returns the improvement cost as an inline library property.
+ */
+export const createImprovementCost = (translate, improvementCost) => ({
+    label: translate("Improvement Cost"),
+    value: improvementCost,
+});

package/lib/entities/partial/rated/skillCheck.d.ts

@@ -0,0 +1,19 @@
+import { SkillCheck, SkillCheckPenalty } from "optolith-database-schema/types/_SkillCheck";
+import { DerivedCharacteristic } from "optolith-database-schema/types/DerivedCharacteristic";
+import { GetById } from "../../../helpers/getTypes.js";
+import { Translate, TranslateMap } from "../../../helpers/translate.js";
+import { LibraryEntryContent } from "../../../libraryEntry.js";
+import { ResponsiveTextSize } from "../responsiveText.js";
+/**
+ * Returns the skill check as an inline library property.
+ */
+export declare const getTextForCheck: (deps: {
+    translate: Translate;
+    translateMap: TranslateMap;
+    getAttributeById: GetById.Static.Attribute;
+}, check: SkillCheck, checkPenalty?: {
+    value: SkillCheckPenalty | undefined;
+    responsiveText: ResponsiveTextSize;
+    getSpirit: () => DerivedCharacteristic | undefined;
+    getToughness: () => DerivedCharacteristic | undefined;
+}) => LibraryEntryContent;

package/lib/entities/partial/rated/skillCheck.js

@@ -0,0 +1,58 @@
+import { assertExhaustive } from "@optolith/helpers/typeSafety";
+import { responsive } from "../responsiveText.js";
+/**
+ * Returns the skill check as an inline library property.
+ */
+export const getTextForCheck = (deps, check, checkPenalty) => ({
+    label: deps.translate("Check"),
+    value: check
+        .map(({ id: { attribute: id } }) => deps.translateMap(deps.getAttributeById(id)?.translations)
+        ?.abbreviation ?? "??")
+        .join("/") +
+        (() => {
+            if (checkPenalty?.value === undefined) {
+                return "";
+            }
+            const { responsiveText } = checkPenalty;
+            const getDerivedCharacteristicTranslation = (getDerivedCharacteristic) => deps.translateMap(getDerivedCharacteristic()?.translations);
+            const getSpiritTranslation = () => getDerivedCharacteristicTranslation(checkPenalty.getSpirit);
+            const getToughnessTranslation = () => getDerivedCharacteristicTranslation(checkPenalty.getToughness);
+            const penalty = (() => {
+                switch (checkPenalty.value) {
+                    case "Spirit": {
+                        const translation = getSpiritTranslation();
+                        return translation === undefined
+                            ? ""
+                            : responsive(responsiveText, () => translation.name, () => translation.abbreviation);
+                    }
+                    case "HalfOfSpirit": {
+                        const translation = getSpiritTranslation();
+                        return translation === undefined
+                            ? ""
+                            : responsive(responsiveText, () => `${translation.name}/2`, () => `${translation.abbreviation}/2`);
+                    }
+                    case "Toughness": {
+                        const translation = getToughnessTranslation();
+                        return translation === undefined
+                            ? ""
+                            : responsive(responsiveText, () => `${translation.name}/2`, () => `${translation.abbreviation}/2`);
+                    }
+                    case "HigherOfSpiritAndToughness": {
+                        const spiritTranslation = getSpiritTranslation();
+                        const toughnessTranslation = getToughnessTranslation();
+                        return spiritTranslation === undefined ||
+                            toughnessTranslation === undefined
+                            ? ""
+                            : responsive(responsiveText, () => deps.translate("{0} or {1}, depending on which value is higher", spiritTranslation.abbreviation, toughnessTranslation.abbreviation), () => `${spiritTranslation.abbreviation}/${toughnessTranslation.abbreviation}`);
+                    }
+                    case "SummoningDifficulty":
+                        return responsive(responsiveText, () => deps.translate("Invocation Difficulty"), () => deps.translate("ID"));
+                    case "CreationDifficulty":
+                        return responsive(responsiveText, () => deps.translate("Creation Difficulty"), () => deps.translate("CD"));
+                    default:
+                        return assertExhaustive(checkPenalty.value);
+                }
+            })();
+            return responsive(responsiveText, () => deps.translate(" (modified by {0})", penalty), () => deps.translate(" (− {0})", penalty));
+        })(),
+});

package/lib/entities/partial/responsiveText.d.ts

@@ -0,0 +1,31 @@
+import { LocaleMap } from "optolith-database-schema/types/_LocaleMap";
+import { ResponsiveText, ResponsiveTextOptional, ResponsiveTextReplace } from "optolith-database-schema/types/_ResponsiveText";
+import { TranslateMap } from "../../helpers/translate.js";
+/**
+ * Whether the entry is displayed in a normal or compressed setting. Normal/full
+ * usually means a full library entry display, whether compressed usually means
+ * the character sheet.
+ */
+export declare enum ResponsiveTextSize {
+    Compressed = 0,
+    Full = 1
+}
+/**
+ * Executes one of two functions depending on the responsive text size.
+ */
+export declare const responsive: <T, A extends unknown[]>(size: ResponsiveTextSize, full: (...args: A) => T, compressed: (...args: A) => T, ...args: A) => T;
+/**
+ * Returns the responsive text for a given size.
+ */
+export declare const getResponsiveText: (value: ResponsiveText | undefined, size: ResponsiveTextSize) => string;
+/**
+ * Returns the responsive text for a given size if it is defined.
+ */
+export declare const getResponsiveTextOptional: (value: ResponsiveTextOptional | undefined, size: ResponsiveTextSize) => string | undefined;
+/**
+ * Replaces a text with a given value if a replacement is requested, otherwise
+ * just return the .
+ */
+export declare const replaceTextIfRequested: (translation: LocaleMap<{
+    replacement?: ResponsiveTextReplace;
+}> | undefined, valueToReplace: string, translateMap: TranslateMap, responsiveText: ResponsiveTextSize) => string;

package/lib/entities/partial/responsiveText.js

@@ -0,0 +1,49 @@
+import { mapNullable } from "@optolith/helpers/nullable";
+import { assertExhaustive } from "@optolith/helpers/typeSafety";
+import { MISSING_VALUE } from "./unknown.js";
+/**
+ * Whether the entry is displayed in a normal or compressed setting. Normal/full
+ * usually means a full library entry display, whether compressed usually means
+ * the character sheet.
+ */
+export var ResponsiveTextSize;
+(function (ResponsiveTextSize) {
+    ResponsiveTextSize[ResponsiveTextSize["Compressed"] = 0] = "Compressed";
+    ResponsiveTextSize[ResponsiveTextSize["Full"] = 1] = "Full";
+})(ResponsiveTextSize || (ResponsiveTextSize = {}));
+/**
+ * Executes one of two functions depending on the responsive text size.
+ */
+export const responsive = (size, full, compressed, ...args) => {
+    switch (size) {
+        case ResponsiveTextSize.Compressed:
+            return compressed(...args);
+        case ResponsiveTextSize.Full:
+            return full(...args);
+        default:
+            return assertExhaustive(size);
+    }
+};
+/**
+ * Returns the responsive text for a given size.
+ */
+export const getResponsiveText = (value, size) => {
+    if (value === undefined) {
+        return MISSING_VALUE;
+    }
+    return responsive(size, () => value.full, () => value.compressed);
+};
+/**
+ * Returns the responsive text for a given size if it is defined.
+ */
+export const getResponsiveTextOptional = (value, size) => {
+    if (value === undefined) {
+        return MISSING_VALUE;
+    }
+    return responsive(size, () => value.full, () => value.compressed);
+};
+/**
+ * Replaces a text with a given value if a replacement is requested, otherwise
+ * just return the .
+ */
+export const replaceTextIfRequested = (translation, valueToReplace, translateMap, responsiveText) => mapNullable(translateMap(translation)?.replacement, (replacement) => getResponsiveText(replacement, responsiveText).replace("$1", valueToReplace)) ?? valueToReplace;

package/lib/entities/partial/unknown.d.ts

@@ -0,0 +1,4 @@
+/**
+ * String to display when a translation that should be present is missing.
+ */
+export declare const MISSING_VALUE = "???";

package/lib/entities/partial/unknown.js

@@ -0,0 +1,4 @@
+/**
+ * String to display when a translation that should be present is missing.
+ */
+export const MISSING_VALUE = "???";

package/lib/entities/skill.d.ts

@@ -0,0 +1,13 @@
+import { NewApplicationsAndUsesCache } from "optolith-database-schema/cache/newApplicationsAndUses";
+import { Skill } from "optolith-database-schema/types/Skill";
+import { All, GetById } from "../helpers/getTypes.js";
+/**
+ * Get a JSON representation of the rules text for a skill.
+ */
+export declare const getSkillLibraryEntry: import("../libraryEntry.js").LibraryEntryCreator<Skill | undefined, {
+    getAttributeById: GetById.Static.Attribute;
+    blessedTraditions: All.Static.BlessedTraditions;
+    diseases: All.Static.Diseases;
+    regions: All.Static.Regions;
+    cache: NewApplicationsAndUsesCache;
+}, import("../libraryEntry.js").LibraryEntry>;

package/lib/entities/skill.js

@@ -0,0 +1,109 @@
+import { isNotNullish } from "@optolith/helpers/nullable";
+import { assertExhaustive } from "@optolith/helpers/typeSafety";
+import { createLibraryEntryCreator } from "../libraryEntry.js";
+import { createImprovementCost } from "./partial/rated/improvementCost.js";
+import { getTextForCheck } from "./partial/rated/skillCheck.js";
+/**
+ * Get a JSON representation of the rules text for a skill.
+ */
+export const getSkillLibraryEntry = createLibraryEntryCreator((entry, { getAttributeById, blessedTraditions, diseases, regions, cache }) => ({ translate, translateMap, localeCompare }) => {
+    const translation = translateMap(entry.translations);
+    if (translation === undefined) {
+        return undefined;
+    }
+    const newApplications = (entry === undefined ? [] : cache.newApplications[entry.id] ?? [])
+        .map((x) => translateMap(x.data.translations)?.name)
+        .filter(isNotNullish)
+        .sort(localeCompare);
+    const uses = (entry === undefined ? [] : cache.uses[entry.id] ?? [])
+        .map((x) => translateMap(x.data.translations)?.name)
+        .filter(isNotNullish)
+        .sort(localeCompare);
+    const applications = (() => {
+        switch (entry.applications.tag) {
+            case "Derived":
+                return (() => {
+                    switch (entry.applications.derived) {
+                        case "BlessedTraditions":
+                            return Object.values(blessedTraditions)
+                                .map((x) => translateMap(x.translations)?.name)
+                                .filter(isNotNullish)
+                                .sort(localeCompare);
+                        case "Diseases":
+                            return Object.values(diseases)
+                                .map((x) => translateMap(x.translations)?.name)
+                                .filter(isNotNullish)
+                                .sort(localeCompare);
+                        case "Regions":
+                            return Object.values(regions)
+                                .map((x) => translateMap(x.translations)?.name)
+                                .filter(isNotNullish)
+                                .sort(localeCompare);
+                        default:
+                            return assertExhaustive(entry.applications.derived);
+                    }
+                })();
+            case "Explicit":
+                return entry.applications.explicit
+                    .map((x) => translateMap(x.translations)?.name)
+                    .filter(isNotNullish)
+                    .sort(localeCompare);
+            default:
+                return assertExhaustive(entry.applications);
+        }
+    })();
+    return {
+        title: translation.name,
+        className: "skill",
+        content: [
+            newApplications.length === 0
+                ? undefined
+                : {
+                    label: translate("New Applications"),
+                    value: newApplications.join(", "),
+                },
+            uses.length === 0
+                ? undefined
+                : {
+                    label: translate("Uses"),
+                    value: uses.join(", "),
+                },
+            getTextForCheck({ translate, translateMap, getAttributeById }, entry.check),
+            {
+                label: translate("Applications"),
+                value: applications.join(", "),
+            },
+            {
+                label: translate("Encumbrance"),
+                value: entry.encumbrance === "True"
+                    ? translate("Yes")
+                    : entry.encumbrance === "False"
+                        ? translate("No")
+                        : translation.encumbrance_description ?? translate("Maybe"),
+            },
+            translation?.tools === undefined
+                ? undefined
+                : {
+                    label: translate("Tools"),
+                    value: translation.tools,
+                },
+            {
+                label: translate("Quality"),
+                value: translation.quality,
+            },
+            {
+                label: translate("Failed Check"),
+                value: translation.failed,
+            },
+            {
+                label: translate("Critical Success"),
+                value: translation.critical,
+            },
+            {
+                label: translate("Botch"),
+                value: translation.botch,
+            },
+            createImprovementCost(translate, entry.improvement_cost),
+        ],
+    };
+});

package/lib/entities/spell.d.ts

@@ -0,0 +1,38 @@
+import { Cantrip } from "optolith-database-schema/types/Cantrip";
+import { DerivedCharacteristic } from "optolith-database-schema/types/DerivedCharacteristic";
+import { Ritual } from "optolith-database-schema/types/Ritual";
+import { Spell } from "optolith-database-schema/types/Spell";
+import { GetById } from "../helpers/getTypes.js";
+/**
+ * Get a JSON representation of the rules text for a cantrip.
+ */
+export declare const getCantripLibraryEntry: import("../libraryEntry.js").LibraryEntryCreator<Cantrip | undefined, {
+    getTargetCategoryById: GetById.Static.TargetCategory;
+    getPropertyById: GetById.Static.Property;
+    getMagicalTraditionById: GetById.Static.MagicalTradition;
+    getCurriculumById: GetById.Static.Curriculum;
+}, import("../libraryEntry.js").LibraryEntry>;
+/**
+ * Get a JSON representation of the rules text for a skill.
+ */
+export declare const getSpellLibraryEntry: import("../libraryEntry.js").LibraryEntryCreator<Spell | undefined, {
+    getAttributeById: GetById.Static.Attribute;
+    getSpirit: () => DerivedCharacteristic | undefined;
+    getToughness: () => DerivedCharacteristic | undefined;
+    getSkillModificationLevelById: GetById.Static.SkillModificationLevel;
+    getTargetCategoryById: GetById.Static.TargetCategory;
+    getPropertyById: GetById.Static.Property;
+    getMagicalTraditionById: GetById.Static.MagicalTradition;
+}, import("../libraryEntry.js").LibraryEntry>;
+/**
+ * Get a JSON representation of the rules text for a ritual.
+ */
+export declare const getRitualLibraryEntry: import("../libraryEntry.js").LibraryEntryCreator<Ritual | undefined, {
+    getAttributeById: GetById.Static.Attribute;
+    getSpirit: () => DerivedCharacteristic | undefined;
+    getToughness: () => DerivedCharacteristic | undefined;
+    getSkillModificationLevelById: GetById.Static.SkillModificationLevel;
+    getTargetCategoryById: GetById.Static.TargetCategory;
+    getPropertyById: GetById.Static.Property;
+    getMagicalTraditionById: GetById.Static.MagicalTradition;
+}, import("../libraryEntry.js").LibraryEntry>;