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/Skill/accessors.js

@@ -0,0 +1,140 @@
+/**
+ *
+ * @param skill
+ */
+export function getDescription(skill) {
+    return skill.description;
+}
+/**
+ *
+ * @param skill
+ */
+export function getEntityTypeId(skill) {
+    return skill.entityTypeId;
+}
+/**
+ *
+ * @param skill
+ */
+export function getExpertise(skill) {
+    return skill.expertise;
+}
+/**
+ *
+ * @param skill
+ */
+export function getHalfProficiency(skill) {
+    return skill.halfProficiency;
+}
+/**
+ *
+ * @param skill
+ */
+export function getId(skill) {
+    return skill.id;
+}
+/**
+ *
+ * @param skill
+ */
+export function getIsOverridden(skill) {
+    return skill.isOverridden;
+}
+/**
+ *
+ * @param skill
+ */
+export function getModifier(skill) {
+    return skill.modifier;
+}
+/**
+ *
+ * @param skill
+ */
+export function getModifierBonuses(skill) {
+    return skill.modifierBonuses;
+}
+/**
+ *
+ * @param skill
+ */
+export function getName(skill) {
+    return skill.name;
+}
+/**
+ *
+ * @param skill
+ */
+export function getProficiency(skill) {
+    return skill.proficiency;
+}
+/**
+ *
+ * @param skill
+ */
+export function getProficiencyBonus(skill) {
+    return skill.proficiencyBonus;
+}
+/**
+ *
+ * @param skill
+ */
+export function getProficiencyLevel(skill) {
+    return skill.proficiencyLevel;
+}
+/**
+ *
+ * @param skill
+ */
+export function getStat(skill) {
+    return skill.stat;
+}
+/**
+ *
+ * @param skill
+ */
+export function getStatModifier(skill) {
+    return skill.statModifier;
+}
+/**
+ *
+ * @param skill
+ */
+export function isCustom(skill) {
+    return skill.isCustom;
+}
+/**
+ *
+ * @param skill
+ */
+export function getNotes(skill) {
+    return skill.notes;
+}
+/**
+ *
+ * @param skill
+ */
+export function getOriginalContract(skill) {
+    return skill.originalContract;
+}
+/**
+ *
+ * @param skill
+ */
+export function getAdvantageAdjustments(skill) {
+    return skill.advantageAdjustments;
+}
+/**
+ *
+ * @param skill
+ */
+export function getDisadvantageAdjustments(skill) {
+    return skill.disadvantageAdjustments;
+}
+/**
+ *
+ * @param skill
+ */
+export function getUsableDiceAdjustmentType(skill) {
+    return skill.usableDiceAdjustmentType;
+}

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

@@ -0,0 +1,45 @@
+import { AbilitySkillEnum, StealthCheckTypeEnum } from '../Core';
+import { DataOriginGenerators, DataOriginTypeEnum } from '../DataOrigin';
+import { DiceAdjustmentRollTypeEnum, DiceAdjustmentTypeEnum } from '../Dice';
+import { ItemAccessors } from '../Item';
+import { ModifierDerivers, ModifierValidators } from '../Modifier';
+import { hack__updateDisadvantageAdjustments } from './hacks';
+/**
+ *
+ * @param skill
+ * @param modifiers
+ */
+export function deriveAdvantageAdjustments(skill, modifiers) {
+    return modifiers
+        .filter((modifier) => ModifierValidators.isValidSkillAdvantageModifier(modifier, skill))
+        .map((modifier) => ModifierDerivers.deriveDiceAdjustment(modifier, DiceAdjustmentTypeEnum.ADVANTAGE));
+}
+/**
+ *
+ * @param skill
+ * @param modifiers
+ * @param equippedArmor
+ * @param nonProficientEquippedArmor
+ */
+export function deriveDisadvantageAdjustments(skill, modifiers, equippedArmor, nonProficientEquippedArmor) {
+    let skillDiceAdjustments = modifiers
+        .filter((modifier) => ModifierValidators.isValidSkillDisadvantageModifier(modifier, skill))
+        .map((modifier) => ModifierDerivers.deriveDiceAdjustment(modifier, DiceAdjustmentTypeEnum.DISADVANTAGE));
+    if (skill.id === AbilitySkillEnum.STEALTH) {
+        equippedArmor.forEach((item) => {
+            if (ItemAccessors.getStealthCheck(item) === StealthCheckTypeEnum.DISADVANTAGE) {
+                skillDiceAdjustments.push({
+                    type: DiceAdjustmentTypeEnum.DISADVANTAGE,
+                    rollType: DiceAdjustmentRollTypeEnum.ABILITY_CHECK,
+                    dataOrigin: DataOriginGenerators.generateDataOrigin(DataOriginTypeEnum.ITEM, item),
+                    restriction: 'with armor worn',
+                    uniqueKey: [ItemAccessors.getUniqueKey(item), 'INNATE'].join('-'),
+                    statId: null,
+                    amount: null,
+                });
+            }
+        });
+    }
+    skillDiceAdjustments = hack__updateDisadvantageAdjustments(skill, skillDiceAdjustments, nonProficientEquippedArmor);
+    return skillDiceAdjustments;
+}

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

@@ -0,0 +1,211 @@
+import { keyBy } from 'lodash';
+import { AbilityDerivers } from '../Ability';
+import { CharacterDerivers } from '../Character';
+import { ProficiencyLevelEnum, ProficiencyRoundingEnum } from '../Core';
+import { DiceDerivers } from '../Dice';
+import { ItemUtils, ItemValidators } from '../Item';
+import { ModifierDerivers, ModifierValidators } from '../Modifier';
+import { RuleDataAccessors } from '../RuleData';
+import { AdjustmentTypeEnum, ValueHacks, ValueUtils } from '../Value';
+import { getId } from './accessors';
+import { deriveAdvantageAdjustments, deriveDisadvantageAdjustments } from './derivers';
+/**
+ *
+ * @param proficiencies
+ * @param proficiencyBonus
+ * @param abilityLookup
+ * @param modifiers
+ * @param equippedItems
+ */
+export function generateCustomSkills(proficiencies, proficiencyBonus, abilityLookup, modifiers, equippedItems) {
+    const equippedArmor = equippedItems.filter(ItemUtils.isArmorContract);
+    const nonProficientEquippedArmor = equippedItems.filter(ItemValidators.isNonProficientEquippedArmorItem);
+    return proficiencies.map((skill) => generateCustomSkill(skill, proficiencyBonus, abilityLookup, modifiers, equippedArmor, nonProficientEquippedArmor));
+}
+/**
+ *
+ * @param customSkill
+ * @param proficiencyBonus
+ * @param abilityLookup
+ * @param modifiers
+ * @param equippedArmor
+ * @param nonProficientEquippedArmor
+ */
+export function generateCustomSkill(customSkill, proficiencyBonus, abilityLookup, modifiers, equippedArmor, nonProficientEquippedArmor) {
+    var _a, _b, _c;
+    let modifier = null;
+    let statModifier = 0;
+    let skillProficiencyBonus = 0;
+    const proficiencyLevel = customSkill.proficiencyLevel ? customSkill.proficiencyLevel : ProficiencyLevelEnum.NONE;
+    const name = customSkill.name ? customSkill.name : 'Unknown Custom Skill';
+    if (customSkill.statId) {
+        statModifier = AbilityDerivers.deriveStatModifier(customSkill.statId, abilityLookup);
+        if (statModifier !== null) {
+            skillProficiencyBonus = CharacterDerivers.deriveProficiencyBonusAmount(proficiencyLevel, proficiencyBonus);
+        }
+    }
+    let modifierBonuses = 0;
+    if (customSkill.override !== null) {
+        modifier = customSkill.override;
+    }
+    else if (statModifier !== null) {
+        const miscBonus = (_a = customSkill.miscBonus) !== null && _a !== void 0 ? _a : 0;
+        const magicBonus = (_b = customSkill.magicBonus) !== null && _b !== void 0 ? _b : 0;
+        modifierBonuses = miscBonus + magicBonus;
+        modifier = statModifier + skillProficiencyBonus + modifierBonuses;
+    }
+    const simulatedSkillContract = {
+        description: null,
+        entityTypeId: -1,
+        id: -1,
+        name: null,
+        stat: (_c = customSkill.statId) !== null && _c !== void 0 ? _c : -1,
+    };
+    const advantageAdjustments = deriveAdvantageAdjustments(simulatedSkillContract, modifiers);
+    const disadvantageAdjustments = deriveDisadvantageAdjustments(simulatedSkillContract, modifiers, equippedArmor, nonProficientEquippedArmor);
+    return {
+        description: customSkill.description,
+        entityTypeId: -1,
+        id: customSkill.id,
+        name,
+        stat: customSkill.statId,
+        isOverridden: customSkill.override !== null,
+        modifier,
+        modifierBonuses,
+        expertise: proficiencyLevel === ProficiencyLevelEnum.EXPERT,
+        halfProficiency: proficiencyLevel === ProficiencyLevelEnum.HALF,
+        proficiency: proficiencyLevel === ProficiencyLevelEnum.FULL,
+        proficiencyLevel,
+        proficiencyBonus: skillProficiencyBonus,
+        notes: customSkill.notes,
+        statModifier,
+        isCustom: true,
+        originalContract: customSkill,
+        advantageAdjustments,
+        disadvantageAdjustments,
+        usableDiceAdjustmentType: DiceDerivers.deriveUsableDiceAdjustmentType(advantageAdjustments, disadvantageAdjustments),
+    };
+}
+/**
+ *
+ * @param skill
+ * @param abilityLookup
+ * @param modifiers
+ * @param proficiencyBonus
+ * @param valueLookup
+ * @param equippedArmor
+ * @param nonProficientEquippedArmor
+ */
+export function generateSkill(skill, abilityLookup, modifiers, proficiencyBonus, valueLookup, equippedArmor, nonProficientEquippedArmor) {
+    let stat = skill.stat;
+    const statOverride = ValueUtils.getKeyValue(valueLookup, AdjustmentTypeEnum.SKILL_STAT_OVERRIDE, ValueHacks.hack__toString(skill.id), ValueHacks.hack__toString(skill.entityTypeId));
+    if (statOverride !== null) {
+        stat = statOverride;
+    }
+    const statModifier = AbilityDerivers.deriveStatModifier(stat, abilityLookup);
+    // This is done so that Modifier validators can check for correct stat ID
+    const overriddenSkill = Object.assign(Object.assign({}, skill), { stat });
+    let proficiencyLevel = ProficiencyLevelEnum.NONE;
+    let proficiencyRounding = ProficiencyRoundingEnum.DOWN;
+    let halfProficiency = false;
+    if (modifiers.filter((modifier) => ModifierValidators.isValidAbilitySkillHalfProficiencyModifier(modifier, overriddenSkill)).length) {
+        halfProficiency = true;
+        proficiencyLevel = ProficiencyLevelEnum.HALF;
+    }
+    if (modifiers.filter((modifier) => ModifierValidators.isValidAbilitySkillHalfProficiencyRoundUpModifier(modifier, overriddenSkill)).length) {
+        halfProficiency = true;
+        proficiencyRounding = ProficiencyRoundingEnum.UP;
+        proficiencyLevel = ProficiencyLevelEnum.HALF;
+    }
+    let proficiency = false;
+    if (modifiers.filter((modifier) => ModifierValidators.isValidAbilitySkillProficiencyModifier(modifier, overriddenSkill)).length) {
+        proficiency = true;
+        proficiencyLevel = ProficiencyLevelEnum.FULL;
+    }
+    let expertise = false;
+    if (modifiers.filter((modifier) => ModifierValidators.isValidAbilitySkillExpertiseModifier(modifier, overriddenSkill)).length) {
+        expertise = true;
+        proficiencyLevel = ProficiencyLevelEnum.EXPERT;
+    }
+    const levelOverride = ValueUtils.getKeyValue(valueLookup, AdjustmentTypeEnum.SKILL_PROFICIENCY_LEVEL, ValueHacks.hack__toString(overriddenSkill.id), ValueHacks.hack__toString(overriddenSkill.entityTypeId));
+    if (levelOverride !== null) {
+        // TODO need to fix this ugliness to be based on proficiency level (components and half round up need to be considered)
+        switch (levelOverride) {
+            case ProficiencyLevelEnum.EXPERT:
+                halfProficiency = false;
+                proficiencyRounding = ProficiencyRoundingEnum.DOWN;
+                proficiency = false;
+                expertise = true;
+                break;
+            case ProficiencyLevelEnum.FULL:
+                halfProficiency = false;
+                proficiencyRounding = ProficiencyRoundingEnum.DOWN;
+                proficiency = true;
+                expertise = false;
+                break;
+            case ProficiencyLevelEnum.HALF:
+                halfProficiency = true;
+                proficiencyRounding = ProficiencyRoundingEnum.DOWN;
+                proficiency = false;
+                expertise = false;
+                break;
+            case ProficiencyLevelEnum.NONE:
+                halfProficiency = false;
+                proficiencyRounding = ProficiencyRoundingEnum.DOWN;
+                proficiency = false;
+                expertise = false;
+                break;
+            default:
+            // not implemented
+        }
+        proficiencyLevel = levelOverride;
+    }
+    const overrideValue = ValueUtils.getKeyValue(valueLookup, AdjustmentTypeEnum.SKILL_OVERRIDE, ValueHacks.hack__toString(overriddenSkill.id), ValueHacks.hack__toString(overriddenSkill.entityTypeId));
+    let modifier = 0;
+    let modifierBonuses = 0;
+    let skillProficiencyBonus = 0;
+    const isOverridden = overrideValue !== null;
+    if (!isOverridden) {
+        const bonusAbilitySkillModifiers = modifiers.filter((modifier) => ModifierValidators.isValidAbilitySkillBonusModifier(modifier, overriddenSkill));
+        const bonusAbilitySkillModifierTotal = ModifierDerivers.sumModifiers(bonusAbilitySkillModifiers, abilityLookup);
+        const miscBonus = ValueUtils.getKeyValue(valueLookup, AdjustmentTypeEnum.SKILL_MISC_BONUS, ValueHacks.hack__toString(overriddenSkill.id), ValueHacks.hack__toString(overriddenSkill.entityTypeId), 0);
+        const magicBonus = ValueUtils.getKeyValue(valueLookup, AdjustmentTypeEnum.SKILL_MAGIC_BONUS, ValueHacks.hack__toString(overriddenSkill.id), ValueHacks.hack__toString(overriddenSkill.entityTypeId), 0);
+        modifierBonuses = miscBonus + magicBonus + bonusAbilitySkillModifierTotal;
+        skillProficiencyBonus = CharacterDerivers.deriveProficiencyBonusAmount(proficiencyLevel, proficiencyBonus, proficiencyRounding);
+        modifier = statModifier + skillProficiencyBonus + modifierBonuses;
+    }
+    else {
+        modifier = overrideValue;
+    }
+    const advantageAdjustments = deriveAdvantageAdjustments(overriddenSkill, modifiers);
+    const disadvantageAdjustments = deriveDisadvantageAdjustments(overriddenSkill, modifiers, equippedArmor, nonProficientEquippedArmor);
+    return Object.assign(Object.assign({}, overriddenSkill), { statModifier,
+        modifier,
+        modifierBonuses, proficiencyBonus: skillProficiencyBonus, proficiencyLevel,
+        proficiency,
+        halfProficiency,
+        expertise,
+        isOverridden, isCustom: false, notes: null, originalContract: null, advantageAdjustments,
+        disadvantageAdjustments, usableDiceAdjustmentType: DiceDerivers.deriveUsableDiceAdjustmentType(advantageAdjustments, disadvantageAdjustments) });
+}
+/**
+ *
+ * @param abilityLookup
+ * @param modifiers
+ * @param proficiencyBonus
+ * @param ruleData
+ * @param valueLookup
+ * @param equippedItems
+ */
+export function generateSkills(abilityLookup, modifiers, proficiencyBonus, ruleData, valueLookup, equippedItems) {
+    const equippedArmor = equippedItems.filter(ItemUtils.isArmorContract);
+    const nonProficientEquippedArmor = equippedItems.filter(ItemValidators.isNonProficientEquippedArmorItem);
+    return RuleDataAccessors.getAbilitySkills(ruleData).map((skill) => generateSkill(skill, abilityLookup, modifiers, proficiencyBonus, valueLookup, equippedArmor, nonProficientEquippedArmor));
+}
+/**
+ *
+ * @param skills
+ */
+export function generateSkillLookup(skills) {
+    return keyBy(skills, (skill) => getId(skill));
+}

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

@@ -0,0 +1,32 @@
+import { AbilityStatEnum } from '../Core';
+import { DataOriginGenerators, DataOriginTypeEnum } from '../DataOrigin';
+import { DiceAdjustmentRollTypeEnum, DiceAdjustmentTypeEnum } from '../Dice';
+import { ItemAccessors } from '../Item';
+/**
+ *
+ * @param skill
+ * @param skillDiceAdjustments
+ * @param nonProficientEquippedArmor
+ */
+export function hack__updateDisadvantageAdjustments(skill, skillDiceAdjustments, nonProficientEquippedArmor) {
+    const newDiceAdjustments = [];
+    switch (skill.stat) {
+        case AbilityStatEnum.STRENGTH:
+        case AbilityStatEnum.DEXTERITY:
+            nonProficientEquippedArmor.forEach((item) => {
+                newDiceAdjustments.push({
+                    type: DiceAdjustmentTypeEnum.DISADVANTAGE,
+                    rollType: DiceAdjustmentRollTypeEnum.ABILITY_CHECK,
+                    dataOrigin: DataOriginGenerators.generateDataOrigin(DataOriginTypeEnum.ITEM, item),
+                    restriction: 'when not proficient with armor worn',
+                    uniqueKey: [ItemAccessors.getUniqueKey(item), 'NOT_PROFICIENT'].join('-'),
+                    statId: null,
+                    amount: null,
+                });
+            });
+            break;
+        default:
+        // not implemented;
+    }
+    return [...skillDiceAdjustments, ...newDiceAdjustments];
+}

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

@@ -0,0 +1,8 @@
+import * as SkillAccessors from './accessors';
+import * as SkillDerivers from './derivers';
+import * as SkillGenerators from './generators';
+import * as SkillTypings from './typings';
+import * as SkillValidators from './validators';
+export * from './typings';
+export { SkillAccessors, SkillDerivers, SkillGenerators, SkillValidators };
+export default Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, SkillAccessors), SkillDerivers), SkillGenerators), SkillTypings), SkillValidators);

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

@@ -0,0 +1,23 @@
+import { UsableDiceAdjustmentTypeEnum } from '../Dice';
+import { getUsableDiceAdjustmentType } from './accessors';
+/**
+ *
+ * @param skill
+ */
+export function isAdvantageUsableDiceAdjustmentType(skill) {
+    return getUsableDiceAdjustmentType(skill) === UsableDiceAdjustmentTypeEnum.ADVANTAGE;
+}
+/**
+ *
+ * @param skill
+ */
+export function isDisadvantageUsableDiceAdjustmentType(skill) {
+    return getUsableDiceAdjustmentType(skill) === UsableDiceAdjustmentTypeEnum.DISADVANTAGE;
+}
+/**
+ *
+ * @param skill
+ */
+export function isAdvantageDisadvantageUsableDiceAdjustmentType(skill) {
+    return getUsableDiceAdjustmentType(skill) === UsableDiceAdjustmentTypeEnum.ADVANTAGE_DISADVANTAGE;
+}