Grabbed dndbeyond's source code

```
~/go/bin/sourcemapper -output ddb -jsurl https://media.dndbeyond.com/character-app/static/js/main.90aa78c5.js
```

ddb_main/packages/rules-engine/es/engine/Infusion/accessors.js

@@ -0,0 +1,185 @@
+export function getChoiceKey(infusion) {
+    return infusion.choiceKey;
+}
+export function getCharacterId(infusion) {
+    return infusion.characterId;
+}
+export function getUniqueKey(infusion) {
+    return infusion.uniqueKey;
+}
+export function getCreatureMappingId(infusion) {
+    return infusion.creatureMappingId;
+}
+export function getDefinitionKey(infusion) {
+    return infusion.definitionKey;
+}
+export function getInventoryMappingId(infusion) {
+    return infusion.inventoryMappingId;
+}
+export function getItemId(infusion) {
+    return infusion.itemId;
+}
+export function getItemTypeId(infusion) {
+    return infusion.itemTypeId;
+}
+export function getModifierGroupId(infusion) {
+    return infusion.modifierGroupId;
+}
+export function getMonsterId(infusion) {
+    return infusion.monsterId;
+}
+export function getDefinitionActions(infusion) {
+    var _a, _b;
+    return (_b = (_a = infusion.definition) === null || _a === void 0 ? void 0 : _a.actions) !== null && _b !== void 0 ? _b : [];
+}
+export function getActions(infusion) {
+    return getDefinitionActions(infusion);
+}
+export function getDefinitionAllowDuplicates(infusion) {
+    var _a, _b;
+    return (_b = (_a = infusion.definition) === null || _a === void 0 ? void 0 : _a.allowDuplicates) !== null && _b !== void 0 ? _b : false;
+}
+export function getAllowDuplicates(infusion) {
+    return getDefinitionAllowDuplicates(infusion);
+}
+export function getDefinitionCreatureData(infusion) {
+    var _a, _b;
+    return (_b = (_a = infusion.definition) === null || _a === void 0 ? void 0 : _a.creatureData) !== null && _b !== void 0 ? _b : null;
+}
+export function getCreatureData(infusion) {
+    return getDefinitionCreatureData(infusion);
+}
+export function getDefinitionDefinitionKey(infusion) {
+    var _a, _b;
+    return (_b = (_a = infusion.definition) === null || _a === void 0 ? void 0 : _a.definitionKey) !== null && _b !== void 0 ? _b : null;
+}
+export function getDefinitionDescription(infusion) {
+    var _a, _b;
+    return (_b = (_a = infusion.definition) === null || _a === void 0 ? void 0 : _a.description) !== null && _b !== void 0 ? _b : null;
+}
+export function getDescription(infusion) {
+    return getDefinitionDescription(infusion);
+}
+export function getId(infusion) {
+    var _a, _b;
+    return (_b = (_a = infusion.definition) === null || _a === void 0 ? void 0 : _a.id) !== null && _b !== void 0 ? _b : null;
+}
+export function getDefinitionItemRuleData(infusion) {
+    var _a, _b;
+    return (_b = (_a = infusion.definition) === null || _a === void 0 ? void 0 : _a.itemRuleData) !== null && _b !== void 0 ? _b : null;
+}
+export function getItemRuleData(infusion) {
+    return getDefinitionItemRuleData(infusion);
+}
+export function getDefinitionLevel(infusion) {
+    var _a, _b;
+    return (_b = (_a = infusion.definition) === null || _a === void 0 ? void 0 : _a.level) !== null && _b !== void 0 ? _b : null;
+}
+export function getLevel(infusion) {
+    return getDefinitionLevel(infusion);
+}
+export function getDefinitionModifierData(infusion) {
+    var _a, _b;
+    return (_b = (_a = infusion.definition) === null || _a === void 0 ? void 0 : _a.modifierData) !== null && _b !== void 0 ? _b : [];
+}
+export function getModifierData(infusion) {
+    return getDefinitionModifierData(infusion);
+}
+export function getDefinitionModifierDataType(infusion) {
+    var _a, _b;
+    return (_b = (_a = infusion.definition) === null || _a === void 0 ? void 0 : _a.modifierDataType) !== null && _b !== void 0 ? _b : null;
+}
+export function getModifierDataType(infusion) {
+    return getDefinitionModifierDataType(infusion);
+}
+export function getDefinitionName(infusion) {
+    var _a, _b;
+    return (_b = (_a = infusion.definition) === null || _a === void 0 ? void 0 : _a.name) !== null && _b !== void 0 ? _b : null;
+}
+export function getName(infusion) {
+    return getDefinitionName(infusion);
+}
+export function getDefinitionRequiresAttunement(infusion) {
+    var _a, _b;
+    return (_b = (_a = infusion.definition) === null || _a === void 0 ? void 0 : _a.requiresAttunement) !== null && _b !== void 0 ? _b : false;
+}
+export function requiresAttunement(infusion) {
+    return getDefinitionRequiresAttunement(infusion);
+}
+export function getDefinitionSnippet(infusion) {
+    var _a, _b;
+    return (_b = (_a = infusion.definition) === null || _a === void 0 ? void 0 : _a.snippet) !== null && _b !== void 0 ? _b : null;
+}
+export function getSnippet(infusion) {
+    return getDefinitionSnippet(infusion);
+}
+export function getDefinitionType(infusion) {
+    var _a, _b;
+    return (_b = (_a = infusion.definition) === null || _a === void 0 ? void 0 : _a.type) !== null && _b !== void 0 ? _b : null;
+}
+export function getType(infusion) {
+    return getDefinitionType(infusion);
+}
+/**
+ *
+ * @param infusion
+ */
+export function getAccessType(infusion) {
+    return infusion.accessType;
+}
+/**
+ *
+ * @param infusion
+ */
+export function getSelectedModifierData(infusion) {
+    return infusion.selectedModifierData;
+}
+/**
+ * The deprecation is a lie
+ *
+ * see hack__requiresItemChoice() for details about why
+ *
+ * @deprecated
+ * @param infusion
+ * @returns {boolean}
+ */
+export function requiresItemChoice(infusion) {
+    return infusion.requiresItemChoice;
+}
+/**
+ *
+ * @param infusion
+ */
+export function requiresModifierDataChoice(infusion) {
+    return infusion.requiresModifierDataChoice;
+}
+/**
+ *
+ * @param infusion
+ */
+export function getDefinitionSources(infusion) {
+    var _a, _b;
+    return (_b = (_a = infusion.definition) === null || _a === void 0 ? void 0 : _a.sources) !== null && _b !== void 0 ? _b : [];
+}
+/**
+ *
+ * @param infusion
+ */
+export function getSources(infusion) {
+    return getDefinitionSources(infusion);
+}
+/**
+ *
+ * @param infusion
+ */
+export function getDefinitionIsHomebrew(infusion) {
+    var _a, _b;
+    return (_b = (_a = infusion.definition) === null || _a === void 0 ? void 0 : _a.isHomebrew) !== null && _b !== void 0 ? _b : false;
+}
+/**
+ *
+ * @param infusion
+ */
+export function isHomebrew(infusion) {
+    return getDefinitionIsHomebrew(infusion);
+}

ddb_main/packages/rules-engine/es/engine/Infusion/constants.js

@@ -0,0 +1,20 @@
+export var InfusionTypeEnum;
+(function (InfusionTypeEnum) {
+    InfusionTypeEnum["REPLICATE"] = "replicate";
+    InfusionTypeEnum["AUGMENT"] = "augment";
+    InfusionTypeEnum["CREATURE"] = "creature";
+})(InfusionTypeEnum || (InfusionTypeEnum = {}));
+export var InfusionModifierDataTypeEnum;
+(function (InfusionModifierDataTypeEnum) {
+    InfusionModifierDataTypeEnum["GRANTED"] = "granted";
+    InfusionModifierDataTypeEnum["CLASS_LEVEL"] = "class-level";
+    InfusionModifierDataTypeEnum["DAMAGE_TYPE_CHOICE"] = "damage-type-choice";
+})(InfusionModifierDataTypeEnum || (InfusionModifierDataTypeEnum = {}));
+export var InfusionItemDataRuleTypeEnum;
+(function (InfusionItemDataRuleTypeEnum) {
+    InfusionItemDataRuleTypeEnum["ITEM"] = "item";
+    InfusionItemDataRuleTypeEnum["ARMOR_TYPE"] = "armor-type";
+    InfusionItemDataRuleTypeEnum["WEAPON_CATEGORY"] = "weapon-category";
+    InfusionItemDataRuleTypeEnum["GEAR_TYPE"] = "gear-type";
+    InfusionItemDataRuleTypeEnum["WEAPON_PROPERTY"] = "weapon-property";
+})(InfusionItemDataRuleTypeEnum || (InfusionItemDataRuleTypeEnum = {}));

ddb_main/packages/rules-engine/es/engine/Infusion/derivers.js

@@ -0,0 +1,42 @@
+import { getModifierData, getModifierDataType, getModifierGroupId, getType } from './accessors';
+import { InfusionModifierDataTypeEnum, InfusionTypeEnum } from './constants';
+/**
+ * TODO this needs to consider item information for knownInfusions to be true.
+ * see hack__requiresItemChoice() for more info
+ *
+ * @param infusion
+ */
+export function deriveRequiresItemChoice(infusion) {
+    return getType(infusion) !== InfusionTypeEnum.REPLICATE;
+}
+/**
+ *
+ * @param infusion
+ */
+export function deriveRequiresModifierDataChoice(infusion) {
+    const modifierDataType = getModifierDataType(infusion);
+    if (modifierDataType === null || modifierDataType === InfusionModifierDataTypeEnum.GRANTED) {
+        return false;
+    }
+    return true;
+}
+/**
+ *
+ * @param infusion
+ */
+export function deriveSelectedModifierData(infusion) {
+    const modifierGroupId = getModifierGroupId(infusion);
+    const modifierData = getModifierData(infusion);
+    const modifierDataType = getModifierDataType(infusion);
+    switch (modifierDataType) {
+        case InfusionModifierDataTypeEnum.GRANTED:
+            return modifierData[0];
+        case InfusionModifierDataTypeEnum.CLASS_LEVEL:
+        case InfusionModifierDataTypeEnum.DAMAGE_TYPE_CHOICE:
+            const foundModifierGroup = modifierData.find((dataItem) => dataItem.id === modifierGroupId);
+            return foundModifierGroup ? foundModifierGroup : null;
+        default:
+        // not implemented
+    }
+    return null;
+}

ddb_main/packages/rules-engine/es/engine/Infusion/generators.js

@@ -0,0 +1,65 @@
+import { keyBy } from 'lodash';
+import { TypeScriptUtils } from '../../utils';
+import { DefinitionPoolUtils } from '../DefinitionPool';
+import { HelperUtils } from '../Helper';
+import { getCharacterId, getChoiceKey, getCreatureMappingId, getDefinitionKey, getInventoryMappingId, getUniqueKey, } from './accessors';
+import { deriveRequiresItemChoice, deriveRequiresModifierDataChoice, deriveSelectedModifierData } from './derivers';
+/**
+ *
+ * @param infusions
+ */
+export function generateInventoryInfusionLookup(infusions) {
+    return keyBy(infusions, (infusion) => getInventoryMappingId(infusion));
+}
+/**
+ *
+ * @param infusions
+ */
+export function generateInfusionChoiceInfusionLookup(infusions) {
+    return HelperUtils.generateNonNullLookup(infusions, getUniqueKey);
+}
+/**
+ *
+ * @param infusions
+ */
+export function generateCreatureInfusionLookup(infusions) {
+    return HelperUtils.generateNonNullLookup(infusions, getCreatureMappingId);
+}
+/**
+ *
+ * @param infusionMapping
+ * @param definition
+ */
+export function generateBaseInfusion(infusionMapping, definition) {
+    const characterId = getCharacterId(infusionMapping);
+    const uniqueKey = `${characterId}-${getChoiceKey(infusionMapping)}`;
+    return Object.assign(Object.assign({}, infusionMapping), { definition,
+        uniqueKey });
+}
+/**
+ *
+ * @param infusionMappings
+ * @param definitionPool
+ */
+export function generateInfusions(infusionMappings, definitionPool) {
+    return infusionMappings
+        .map((infusionMapping) => generateInfusion(infusionMapping, definitionPool))
+        .filter(TypeScriptUtils.isNotNullOrUndefined);
+}
+/**
+ *
+ * @param infusionMapping
+ * @param definitionPool
+ */
+export function generateInfusion(infusionMapping, definitionPool) {
+    const definitionKey = getDefinitionKey(infusionMapping);
+    if (definitionKey === null) {
+        return null;
+    }
+    const definition = DefinitionPoolUtils.getInfusionDefinition(definitionKey, definitionPool);
+    if (definition === null) {
+        return null;
+    }
+    const baseInfusion = generateBaseInfusion(infusionMapping, definition);
+    return Object.assign(Object.assign({}, baseInfusion), { accessType: DefinitionPoolUtils.getDefinitionAccessType(definitionKey, definitionPool), selectedModifierData: deriveSelectedModifierData(baseInfusion), requiresItemChoice: deriveRequiresItemChoice(baseInfusion), requiresModifierDataChoice: deriveRequiresModifierDataChoice(baseInfusion) });
+}

ddb_main/packages/rules-engine/es/engine/Infusion/hacks.js

@@ -0,0 +1,34 @@
+import { HelperUtils } from '../Helper';
+import { getType } from './accessors';
+import { InfusionTypeEnum } from './constants';
+/**
+ * This is a temporary workaround til we have item definition game data service.  Once we can
+ * load item definitions as needed, we can fully calculate requiresItemChoice at the
+ * same time as we generate the infusion
+ * @param infusion
+ * @param itemId
+ * @param itemCanBeAddedLookup
+ * @returns {boolean}
+ */
+export function hack__requiresItemChoice(infusion, itemId = null, itemCanBeAddedLookup = {}) {
+    if (getType(infusion) !== InfusionTypeEnum.REPLICATE) {
+        return true;
+    }
+    return !this.hack__itemCanBeAddedToInventory(infusion, itemId, itemCanBeAddedLookup);
+}
+/**
+ *
+ * @param infusion
+ * @param itemId
+ * @param itemCanBeAddedLookup
+ */
+export function hack__itemCanBeAddedToInventory(infusion, itemId, itemCanBeAddedLookup) {
+    if (getType(infusion) !== InfusionTypeEnum.REPLICATE) {
+        return true;
+    }
+    const fallback = false;
+    if (itemId === null) {
+        return fallback;
+    }
+    return HelperUtils.lookupDataOrFallback(itemCanBeAddedLookup, itemId, fallback);
+}

ddb_main/packages/rules-engine/es/engine/Infusion/index.js

@@ -0,0 +1,13 @@
+import * as InfusionAccessors from './accessors';
+import * as InfusionConstants from './constants';
+import * as InfusionDerivers from './derivers';
+import * as InfusionGenerators from './generators';
+import * as InfusionHacks from './hacks';
+import * as InfusionSimulators from './simulators';
+import * as InfusionTypings from './typings';
+import * as InfusionUtils from './utils';
+import * as InfusionValidators from './validators';
+export * from './typings';
+export * from './constants';
+export { InfusionAccessors, InfusionDerivers, InfusionGenerators, InfusionHacks, InfusionSimulators, InfusionUtils, InfusionValidators, };
+export default Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, InfusionAccessors), InfusionConstants), InfusionDerivers), InfusionGenerators), InfusionHacks), InfusionSimulators), InfusionTypings), InfusionUtils), InfusionValidators);

ddb_main/packages/rules-engine/es/engine/Infusion/simulators.js

@@ -0,0 +1,27 @@
+import { DefinitionPoolUtils } from '../DefinitionPool';
+import { deriveRequiresItemChoice, deriveRequiresModifierDataChoice, deriveSelectedModifierData } from './derivers';
+import { generateBaseInfusion } from './generators';
+/**
+ *
+ * @param definitionKey
+ * @param definitionPool
+ */
+export function simulateInfusion(definitionKey, definitionPool) {
+    const infusionDefinition = DefinitionPoolUtils.getInfusionDefinition(definitionKey, definitionPool);
+    if (infusionDefinition === null) {
+        return null;
+    }
+    const simulatedMapping = {
+        characterId: -1,
+        choiceKey: '',
+        creatureMappingId: -1,
+        definitionKey,
+        inventoryMappingId: -1,
+        modifierGroupId: '',
+        monsterId: -1,
+        itemId: -1,
+        itemTypeId: -1,
+    };
+    const baseInfusion = generateBaseInfusion(simulatedMapping, infusionDefinition);
+    return Object.assign(Object.assign({}, baseInfusion), { accessType: DefinitionPoolUtils.getDefinitionAccessType(definitionKey, definitionPool), selectedModifierData: deriveSelectedModifierData(baseInfusion), requiresItemChoice: deriveRequiresItemChoice(baseInfusion), requiresModifierDataChoice: deriveRequiresModifierDataChoice(baseInfusion) });
+}

ddb_main/packages/rules-engine/es/engine/Infusion/utils.js

@@ -0,0 +1,26 @@
+import { ItemAccessors } from '../Item';
+import { getItemRuleData } from './accessors';
+import { hack__itemCanBeAddedToInventory } from './hacks';
+import { validateItemByInfusionRules } from './validators';
+/**
+ *
+ * @param items
+ * @param infusion
+ * @param itemId
+ * @param itemCanBeAddedLookup
+ */
+export function filterAvailableItems(items, infusion, itemId = null, itemCanBeAddedLookup = {}) {
+    if (itemId !== null && !hack__itemCanBeAddedToInventory(infusion, itemId, itemCanBeAddedLookup)) {
+        return items.filter((item) => itemId === ItemAccessors.getGroupedId(item));
+    }
+    const itemRuleData = getItemRuleData(infusion);
+    if (itemRuleData === null) {
+        return [];
+    }
+    let availableItems = [];
+    const andRules = itemRuleData.itemRules !== null ? itemRuleData.itemRules : [];
+    if (andRules.length) {
+        availableItems = items.filter((item) => validateItemByInfusionRules(item, andRules));
+    }
+    return availableItems;
+}

ddb_main/packages/rules-engine/es/engine/Infusion/validators.js

@@ -0,0 +1,68 @@
+import { ItemAccessors } from '../Item';
+import { getLevel } from './accessors';
+import { InfusionItemDataRuleTypeEnum } from './constants';
+/**
+ *
+ * @param rule
+ * @param item
+ */
+export function validateItemByCost(rule, item) {
+    if (rule.costMinimum === null) {
+        return true;
+    }
+    return ItemAccessors.getCost(item) >= rule.costMinimum;
+}
+/**
+ *
+ * @param rule
+ * @param item
+ */
+export function validateItemByRuleType(rule, item) {
+    switch (rule.type) {
+        case InfusionItemDataRuleTypeEnum.ARMOR_TYPE:
+            return ItemAccessors.getArmorTypeId(item) === rule.entityId;
+        case InfusionItemDataRuleTypeEnum.GEAR_TYPE:
+            return ItemAccessors.getGearTypeId(item) === rule.entityId;
+        case InfusionItemDataRuleTypeEnum.ITEM:
+            return (ItemAccessors.getDefinitionId(item) === rule.entityId &&
+                ItemAccessors.getDefinitionEntityTypeId(item) === rule.entityTypeId);
+        case InfusionItemDataRuleTypeEnum.WEAPON_PROPERTY:
+            return ItemAccessors.getProperties(item).some((property) => property.id === rule.entityId);
+        case InfusionItemDataRuleTypeEnum.WEAPON_CATEGORY:
+            return ItemAccessors.getCategoryId(item) === rule.entityId;
+        default:
+        // not implemented
+    }
+    return false;
+}
+/**
+ *
+ * @param rule
+ * @param item
+ */
+export function validateItemByItemRule(rule, item) {
+    return (ItemAccessors.getInfusion(item) === null &&
+        !ItemAccessors.isMagic(item) &&
+        validateItemByRuleType(rule, item) &&
+        validateItemByCost(rule, item));
+}
+/**
+ *
+ * @param infusion
+ * @param contextLevel
+ */
+export function validateIsAvailableByContextLevel(infusion, contextLevel) {
+    const infusionLevel = getLevel(infusion);
+    if (contextLevel !== null && infusionLevel !== null && infusionLevel <= contextLevel) {
+        return true;
+    }
+    return false;
+}
+/**
+ *
+ * @param item
+ * @param andRules
+ */
+export function validateItemByInfusionRules(item, andRules) {
+    return andRules.every((andRule) => !!andRule.rules && andRule.rules.some((orRule) => validateItemByItemRule(orRule, item)));
+}