Grabbed dndbeyond's source code

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

ddb_main/tools/js/Shared/managers/ActionsManagerContext.tsx

@@ -0,0 +1,25 @@
+import React, { useMemo } from "react";
+
+import { ActionsManager } from "@dndbeyond/character-rules-engine/es";
+
+interface ActionsManagerContextValue {
+  actionsManager: ActionsManager;
+}
+
+const initContext: ActionsManagerContextValue = {
+  actionsManager: new ActionsManager(),
+};
+export const ActionsManagerContext =
+  React.createContext<ActionsManagerContextValue>(initContext);
+
+export function ActionsManagerProvider({ children }) {
+  const actionsManager: ActionsManager = useMemo(
+    () => new ActionsManager(),
+    []
+  );
+  return (
+    <ActionsManagerContext.Provider value={{ actionsManager }}>
+      {children}
+    </ActionsManagerContext.Provider>
+  );
+}

ddb_main/tools/js/Shared/managers/AttributesManagerContext.tsx

@@ -0,0 +1,24 @@
+import React, { useMemo } from "react";
+
+import { AttributesManager } from "@dndbeyond/character-rules-engine/es";
+
+interface AttributesManagerContextValue {
+  attributesManager: AttributesManager;
+}
+const initContext: AttributesManagerContextValue = {
+  attributesManager: new AttributesManager(),
+};
+export const AttributesManagerContext =
+  React.createContext<AttributesManagerContextValue>(initContext);
+
+export function AttributesManagerProvider({ children }) {
+  const attributesManager: AttributesManager = useMemo(
+    () => new AttributesManager(),
+    []
+  );
+  return (
+    <AttributesManagerContext.Provider value={{ attributesManager }}>
+      {children}
+    </AttributesManagerContext.Provider>
+  );
+}

ddb_main/tools/js/Shared/managers/CharacterFeaturesManagerContext.tsx

@@ -0,0 +1,26 @@
+import React, { useMemo } from "react";
+
+import { CharacterFeaturesManager } from "@dndbeyond/character-rules-engine/es";
+
+interface CharacterFeaturesManagerContextValue {
+  characterFeaturesManager: CharacterFeaturesManager;
+}
+const initContext: CharacterFeaturesManagerContextValue = {
+  characterFeaturesManager: new CharacterFeaturesManager(),
+};
+export const CharacterFeaturesManagerContext =
+  React.createContext<CharacterFeaturesManagerContextValue>(initContext);
+
+export function CharacterFeaturesManagerProvider({ children }) {
+  const characterFeaturesManager: CharacterFeaturesManager = useMemo(
+    () => new CharacterFeaturesManager(),
+    []
+  );
+  return (
+    <CharacterFeaturesManagerContext.Provider
+      value={{ characterFeaturesManager }}
+    >
+      {children}
+    </CharacterFeaturesManagerContext.Provider>
+  );
+}

ddb_main/tools/js/Shared/managers/CoinManagerContext.tsx

@@ -0,0 +1,21 @@
+import React, { useMemo } from "react";
+
+import { CoinManager } from "@dndbeyond/character-rules-engine/es";
+
+interface CoinManagerContextValue {
+  coinManager: CoinManager | null;
+}
+const initContext: CoinManagerContextValue = {
+  coinManager: null,
+};
+export const CoinManagerContext =
+  React.createContext<CoinManagerContextValue>(initContext);
+
+export function CoinManagerProvider({ children }) {
+  const coinManager: CoinManager = useMemo(() => new CoinManager(), []);
+  return (
+    <CoinManagerContext.Provider value={{ coinManager }}>
+      {children}
+    </CoinManagerContext.Provider>
+  );
+}

ddb_main/tools/js/Shared/managers/ExtrasManagerContext.tsx

@@ -0,0 +1,21 @@
+import React, { useMemo } from "react";
+
+import { ExtrasManager } from "@dndbeyond/character-rules-engine/es";
+
+interface ExtrasManagerContextValue {
+  extrasManager: ExtrasManager;
+}
+const initContext: ExtrasManagerContextValue = {
+  extrasManager: new ExtrasManager(),
+};
+export const ExtrasManagerContext =
+  React.createContext<ExtrasManagerContextValue>(initContext);
+
+export function ExtrasManagerProvider({ children }) {
+  const extrasManager: ExtrasManager = useMemo(() => new ExtrasManager(), []);
+  return (
+    <ExtrasManagerContext.Provider value={{ extrasManager }}>
+      {children}
+    </ExtrasManagerContext.Provider>
+  );
+}

ddb_main/tools/js/Shared/managers/InventoryManagerContext.tsx

@@ -0,0 +1,28 @@
+import React, { useContext, useMemo } from "react";
+
+import { InventoryManager } from "@dndbeyond/character-rules-engine/es";
+
+interface InventoryManagerContextValue {
+  inventoryManager: InventoryManager;
+}
+const initContext: InventoryManagerContextValue = {
+  inventoryManager: new InventoryManager(),
+};
+export const InventoryManagerContext =
+  React.createContext<InventoryManagerContextValue>(initContext);
+
+export function InventoryManagerProvider({ children }) {
+  const inventoryManager: InventoryManager = useMemo(
+    () => new InventoryManager(),
+    []
+  );
+  return (
+    <InventoryManagerContext.Provider value={{ inventoryManager }}>
+      {children}
+    </InventoryManagerContext.Provider>
+  );
+}
+
+export const useInventoryManager = () => {
+  return useContext(InventoryManagerContext);
+};

ddb_main/tools/js/Shared/managers/SpellsManagerContext.tsx

@@ -0,0 +1,26 @@
+import React, { useMemo } from "react";
+
+import {
+  getSpellsManager,
+  SpellsManager,
+} from "@dndbeyond/character-rules-engine/es";
+
+interface SpellsManagerContextValue {
+  spellsManager: SpellsManager;
+}
+
+const initContext: SpellsManagerContextValue = {
+  spellsManager: null!,
+};
+export const SpellsManagerContext =
+  React.createContext<SpellsManagerContextValue>(initContext);
+
+export function SpellsManagerProvider({ children }) {
+  // TODO: try getting the initialized sub and cleaning it up in here?
+  const spellsManager: SpellsManager = useMemo(() => getSpellsManager(), []);
+  return (
+    <SpellsManagerContext.Provider value={{ spellsManager }}>
+      {children}
+    </SpellsManagerContext.Provider>
+  );
+}

ddb_main/tools/js/Shared/managers/index.tsx

@@ -0,0 +1,25 @@
+import { ActionsManagerProvider } from "./ActionsManagerContext";
+import { AttributesManagerProvider } from "./AttributesManagerContext";
+import { CharacterFeaturesManagerProvider } from "./CharacterFeaturesManagerContext";
+import { CoinManagerProvider } from "./CoinManagerContext";
+import { ExtrasManagerProvider } from "./ExtrasManagerContext";
+import { InventoryManagerProvider } from "./InventoryManagerContext";
+import { SpellsManagerProvider } from "./SpellsManagerContext";
+
+export function Managers(props) {
+  return (
+    <ActionsManagerProvider>
+      <AttributesManagerProvider>
+        <ExtrasManagerProvider>
+          <SpellsManagerProvider>
+            <CharacterFeaturesManagerProvider>
+              <InventoryManagerProvider>
+                <CoinManagerProvider>{props.children}</CoinManagerProvider>
+              </InventoryManagerProvider>
+            </CharacterFeaturesManagerProvider>
+          </SpellsManagerProvider>
+        </ExtrasManagerProvider>
+      </AttributesManagerProvider>
+    </ActionsManagerProvider>
+  );
+}