move shared module-scoped state to globals

This is a followup to the change that switch to Symbol.for, with the intent of making it not matter which loader you retrive cardApi from. It turns out we also need to make sure you're sharing the same module-scoped WeakMaps, etc.

Author: ef4

packages/base/card-api.gts

@@ -48,6 +48,7 @@ import {
   type RealmInfo,
 } from '@cardstack/runtime-common';
 import type { ComponentLike } from '@glint/template';
+import { initSharedState } from './shared-state';
 
 export { primitive, isField, type BoxComponent };
 export const serialize = Symbol.for('cardstack-serialize');
@@ -170,10 +171,22 @@ function isStaleValue(value: any): value is StaleValue {
     return false;
   }
 }
-const deserializedData = new WeakMap<BaseDef, Map<string, any>>();
-const recomputePromises = new WeakMap<BaseDef, Promise<any>>();
-const identityContexts = new WeakMap<BaseDef, IdentityContext>();
-const subscribers = new WeakMap<BaseDef, Set<CardChangeSubscriber>>();
+const deserializedData = initSharedState(
+  'deserializedData',
+  () => new WeakMap<BaseDef, Map<string, any>>(),
+);
+const recomputePromises = initSharedState(
+  'recomputePromises',
+  () => new WeakMap<BaseDef, Promise<any>>(),
+);
+const identityContexts = initSharedState(
+  'identityContexts',
+  () => new WeakMap<BaseDef, IdentityContext>(),
+);
+const subscribers = initSharedState(
+  'subscribers',
+  () => new WeakMap<BaseDef, Set<CardChangeSubscriber>>(),
+);
 
 // our place for notifying Glimmer when a card is ready to re-render (which will
 // involve rerunning async computed fields)

packages/base/field-component.gts

@@ -16,6 +16,7 @@ import { getField } from '@cardstack/runtime-common';
 import type { ComponentLike } from '@glint/template';
 import { CardContainer } from '@cardstack/boxel-ui/components';
 import Modifier from 'ember-modifier';
+import { initSharedState } from './shared-state';
 
 interface BoxComponentSignature {
   Args: { Named: { format?: Format } };
@@ -24,7 +25,10 @@ interface BoxComponentSignature {
 
 export type BoxComponent = ComponentLike<BoxComponentSignature>;
 
-const componentCache = new WeakMap<Box<BaseDef>, BoxComponent>();
+const componentCache = initSharedState(
+  'componentCache',
+  () => new WeakMap<Box<BaseDef>, BoxComponent>(),
+);
 
 export function getBoxComponent(
   card: typeof BaseDef,

packages/base/room.gts

@@ -21,6 +21,7 @@ import {
 } from '@cardstack/runtime-common';
 //@ts-expect-error cached type not available yet
 import { cached } from '@glimmer/tracking';
+import { initSharedState } from './shared-state';
 
 // this is so we can have triple equals equivalent room member cards
 function upsertRoomMember({
@@ -275,14 +276,26 @@ interface RoomState {
 
 // in addition to acting as a cache, this also ensures we have
 // triple equal equivalence for the interior cards of RoomField
-const eventCache = new WeakMap<RoomField, Map<string, MatrixEvent>>();
-const messageCache = new WeakMap<RoomField, Map<string, MessageField>>();
-const roomMemberCache = new WeakMap<RoomField, Map<string, RoomMemberField>>();
-const roomStateCache = new WeakMap<RoomField, RoomState>();
-const fragmentCache = new WeakMap<
-  RoomField,
-  Map<string, CardFragmentContent>
->();
+const eventCache = initSharedState(
+  'eventCache',
+  () => new WeakMap<RoomField, Map<string, MatrixEvent>>(),
+);
+const messageCache = initSharedState(
+  'messageCache',
+  () => new WeakMap<RoomField, Map<string, MessageField>>(),
+);
+const roomMemberCache = initSharedState(
+  'roomMemberCache',
+  () => new WeakMap<RoomField, Map<string, RoomMemberField>>(),
+);
+const roomStateCache = initSharedState(
+  'roomStateCache',
+  () => new WeakMap<RoomField, RoomState>(),
+);
+const fragmentCache = initSharedState(
+  'fragmentCache',
+  () => new WeakMap<RoomField, Map<string, CardFragmentContent>>(),
+);
 
 export class RoomField extends FieldDef {
   static displayName = 'Room';

packages/base/shared-state.ts

@@ -0,0 +1,25 @@
+/*
+  This module needs to exist so long as we have multiple loaders cooperating in
+  the same environment. It ensures that any shared global state is really
+  global. Ultimately we would like to get to the point where the loader itself
+  is scoped so broadly that there's only one, and module-scoped state is safe to
+  treat as global.
+*/
+
+const bucket: Map<string, unknown> = (() => {
+  let g = globalThis as unknown as {
+    __card_api_shared_state: Map<string, unknown> | undefined;
+  };
+  if (!g.__card_api_shared_state) {
+    g.__card_api_shared_state = new Map();
+  }
+  return g.__card_api_shared_state;
+})();
+
+export function initSharedState<T>(key: string, fn: () => T): T {
+  if (bucket.has(key)) {
+    return bucket.get(key) as T;
+  }
+  bucket.set(key, fn());
+  return bucket.get(key) as T;
+}