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

@@ -0,0 +1,42 @@
+/**
+ *
+ * @param origin
+ */
+export function getRacialTraitId(origin) {
+    return origin.racialTraitId;
+}
+/**
+ *
+ * @param origin
+ */
+export function getAffectedRacialTraitId(origin) {
+    return origin.affectedRacialTraitId;
+}
+/**
+ *
+ * @param origin
+ */
+export function getDefinitionKey(origin) {
+    return origin.racialTraitDefinitionKey;
+}
+/**
+ *
+ * @param origin
+ */
+export function getAffectedRacialTraitDefinitionKey(origin) {
+    return origin.affectedRacialTraitDefinitionKey;
+}
+/**
+ *
+ * @param origin
+ */
+export function getRacialTrait(origin) {
+    return origin.racialTrait;
+}
+/**
+ *
+ * @param origin
+ */
+export function getAccessType(origin) {
+    return origin.accessType;
+}

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

@@ -0,0 +1,9 @@
+import { DefinitionHacks, DefinitionTypeEnum } from '../Definition';
+/**
+ * use hack until ids are strings
+ *
+ * @param id
+ */
+export function deriveDefinitionKey(id) {
+    return DefinitionHacks.hack__generateDefinitionKey(DefinitionTypeEnum.RACIAL_TRAIT, id);
+}

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

@@ -0,0 +1,34 @@
+import { TypeScriptUtils } from '../../utils';
+import { DefinitionPoolUtils } from '../DefinitionPool';
+import { HelperUtils } from '../Helper';
+import { RacialTraitSimulators } from '../RacialTrait';
+import { getDefinitionKey } from './accessors';
+/**
+ *
+ * @param optionalOriginMappings
+ * @param definitionPool
+ */
+export function generateOptionalOrigins(optionalOriginMappings, definitionPool) {
+    return optionalOriginMappings
+        .map((mapping) => generateOptionalOrigin(mapping, definitionPool))
+        .filter(TypeScriptUtils.isNotNullOrUndefined);
+}
+/**
+ *
+ * @param optionalOriginMapping
+ * @param definitionPool
+ */
+export function generateOptionalOrigin(optionalOriginMapping, definitionPool) {
+    const definitionKey = getDefinitionKey(optionalOriginMapping);
+    if (definitionKey === null) {
+        return null;
+    }
+    return Object.assign(Object.assign({}, optionalOriginMapping), { racialTrait: RacialTraitSimulators.simulateRacialTrait(definitionKey, definitionPool), accessType: DefinitionPoolUtils.getDefinitionAccessType(definitionKey, definitionPool) });
+}
+/**
+ *
+ * @param optionalOrigins
+ */
+export function generateOptionalOriginLookup(optionalOrigins) {
+    return HelperUtils.generateNonNullLookup(optionalOrigins, getDefinitionKey);
+}

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

@@ -0,0 +1,9 @@
+import * as OptionalOriginAccessors from './accessors';
+import * as OptionalOriginDerivers from './derivers';
+import * as OptionalOriginGenerators from './generators';
+import * as OptionalOriginSimulators from './simulators';
+import * as OptionalOriginTypings from './typings';
+import * as OptionalOriginUtils from './utils';
+export * from './typings';
+export { OptionalOriginAccessors, OptionalOriginDerivers, OptionalOriginGenerators, OptionalOriginSimulators, OptionalOriginUtils, };
+export default Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, OptionalOriginAccessors), OptionalOriginDerivers), OptionalOriginGenerators), OptionalOriginTypings), OptionalOriginUtils), OptionalOriginSimulators);

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

@@ -0,0 +1,14 @@
+import { deriveDefinitionKey } from './derivers';
+/**
+ *
+ * @param racialTraitId
+ * @param affectedRacialTraitId
+ */
+export function simulateOptionalOriginContract(racialTraitId, affectedRacialTraitId) {
+    return {
+        affectedRacialTraitId,
+        affectedRacialTraitDefinitionKey: affectedRacialTraitId ? deriveDefinitionKey(affectedRacialTraitId) : null,
+        racialTraitDefinitionKey: racialTraitId ? deriveDefinitionKey(racialTraitId) : null,
+        racialTraitId,
+    };
+}

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

@@ -0,0 +1,39 @@
+import { FeatureTypeEnum } from '../Core';
+import { RacialTraitAccessors } from '../RacialTrait';
+import { getAffectedRacialTraitId, getRacialTrait } from './accessors';
+/**
+ *
+ * @param optionalOrigin
+ */
+export function getOptionalOriginSpellListIds(optionalOrigin) {
+    const spellListIds = [];
+    const racialTrait = getRacialTrait(optionalOrigin);
+    if (racialTrait) {
+        spellListIds.push(...RacialTraitAccessors.getSpellListIds(racialTrait));
+    }
+    return spellListIds;
+}
+/**
+ *
+ * @param optionalOrigin
+ * @param data
+ */
+export function getUpdateMappingSpellListIdsToRemove(optionalOrigin, data) {
+    const spellListIds = [];
+    const existingAffectedRacialTraitId = getAffectedRacialTraitId(optionalOrigin);
+    const racialTrait = getRacialTrait(optionalOrigin);
+    if (racialTrait &&
+        RacialTraitAccessors.getFeatureType(racialTrait) === FeatureTypeEnum.REPLACEMENT &&
+        existingAffectedRacialTraitId !== null &&
+        data.affectedRacialTraitId === null) {
+        spellListIds.push(...getOptionalOriginSpellListIds(optionalOrigin));
+    }
+    return spellListIds;
+}
+/**
+ *
+ * @param optionalOrigin
+ */
+export function getRemoveMappingSpellListIds(optionalOrigin) {
+    return getOptionalOriginSpellListIds(optionalOrigin);
+}