refactor registration callback into separate class

Author: AbanoubGhadban

node_package/src/CallbackRegistry.ts

@@ -0,0 +1,50 @@
+import { ItemRegistrationCallback } from "./types";
+
+export default class CallbackRegistry<T> {
+  private registeredItems = new Map<string, T>();
+  private callbacks = new Map<string, Array<ItemRegistrationCallback<T>>>();
+
+  set(name: string, item: T): void {
+    this.registeredItems.set(name, item);
+    
+    const callbacks = this.callbacks.get(name) || [];
+    callbacks.forEach(callback => {
+      setTimeout(() => callback(item), 0);
+    });
+    this.callbacks.delete(name);
+  }
+
+  get(name: string): T | undefined {
+    return this.registeredItems.get(name);
+  }
+
+  has(name: string): boolean {
+    return this.registeredItems.has(name);
+  }
+
+  clear(): void {
+    this.registeredItems.clear();
+  }
+
+  getAll(): Map<string, T> {
+    return this.registeredItems;
+  }
+
+  onItemRegistered(name: string, callback: ItemRegistrationCallback<T>): void {
+    const existingItem = this.registeredItems.get(name);
+    if (existingItem) {
+      setTimeout(() => callback(existingItem), 0);
+      return;
+    }
+
+    const callbacks = this.callbacks.get(name) || [];
+    callbacks.push(callback);
+    this.callbacks.set(name, callbacks);
+  }
+
+  getOrWaitForItem(name: string): Promise<T> {
+    return new Promise((resolve) => {
+      this.onItemRegistered(name, resolve);
+    });
+  }
+}

node_package/src/ComponentRegistry.ts

@@ -3,12 +3,12 @@ import {
   type RegisteredComponent,
   type ReactComponentOrRenderFunction,
   type RenderFunction,
-  type ComponentRegistrationCallback,
+  type ItemRegistrationCallback,
 } from './types';
 import isRenderFunction from './isRenderFunction';
+import CallbackRegistry from './CallbackRegistry';
 
-const registeredComponents = new Map<string, RegisteredComponent>();
-const registrationCallbacks = new Map<string, Array<ComponentRegistrationCallback>>();
+const componentRegistry = new CallbackRegistry<RegisteredComponent>();
 
 export default {
   /**
@@ -18,27 +18,17 @@ export default {
    */
   onComponentRegistered(
     componentName: string,
-    callback: (component: RegisteredComponent) => void,
+    callback: ItemRegistrationCallback<RegisteredComponent>,
   ): void {
-    // If component is already registered, schedule callback
-    const existingComponent = registeredComponents.get(componentName);
-    if (existingComponent) {
-      setTimeout(() => callback(existingComponent), 0);
-      return;
-    }
-
-    // Store callback for future registration
-    const callbacks = registrationCallbacks.get(componentName) || [];
-    callbacks.push(callback);
-    registrationCallbacks.set(componentName, callbacks);
+    componentRegistry.onItemRegistered(componentName, callback);
   },
 
   /**
    * @param components { component1: component1, component2: component2, etc. }
    */
   register(components: { [id: string]: ReactComponentOrRenderFunction }): void {
     Object.keys(components).forEach(name => {
-      if (registeredComponents.has(name)) {
+      if (componentRegistry.has(name)) {
         console.warn('Called register for component that is already registered', name);
       }
 
@@ -50,19 +40,12 @@ export default {
       const renderFunction = isRenderFunction(component);
       const isRenderer = renderFunction && (component as RenderFunction).length === 3;
 
-      const registeredComponent = {
+      componentRegistry.set(name, {
         name,
         component,
         renderFunction,
         isRenderer,
-      };
-      registeredComponents.set(name, registeredComponent);
-
-      const callbacks = registrationCallbacks.get(name) || [];
-      callbacks.forEach(callback => {
-        setTimeout(() => callback(registeredComponent), 0);
       });
-      registrationCallbacks.delete(name);
     });
   },
 
@@ -82,20 +65,16 @@ export default {
    * @returns { name, component, isRenderFunction, isRenderer }
    */
   get(name: string): RegisteredComponent {
-    const registeredComponent = registeredComponents.get(name);
-    if (registeredComponent !== undefined) {
-      return registeredComponent;
-    }
+    const component = componentRegistry.get(name);
+    if (component !== undefined) return component;
 
-    const keys = Array.from(registeredComponents.keys()).join(', ');
+    const keys = Array.from(componentRegistry.getAll().keys()).join(', ');
     throw new Error(`Could not find component registered with name ${name}. \
 Registered component names include [ ${keys} ]. Maybe you forgot to register the component?`);
   },
 
-  async getOrWaitForComponent(name: string): Promise<RegisteredComponent> {
-    return new Promise((resolve) => {
-      this.onComponentRegistered(name, resolve);
-    });
+  getOrWaitForComponent(name: string): Promise<RegisteredComponent> {
+    return componentRegistry.getOrWaitForItem(name);
   },
 
   /**
@@ -104,6 +83,6 @@ Registered component names include [ ${keys} ]. Maybe you forgot to register the
    * { name, component, renderFunction, isRenderer}
    */
   components(): Map<string, RegisteredComponent> {
-    return registeredComponents;
+    return componentRegistry.getAll();
   },
 };

node_package/src/StoreRegistry.ts

@@ -1,9 +1,8 @@
-import type { Store, StoreGenerator } from './types';
+import CallbackRegistry from './CallbackRegistry';
+import type { Store, StoreGenerator, ItemRegistrationCallback } from './types';
 
-const registeredStoreGenerators = new Map<string, StoreGenerator>();
-const hydratedStores = new Map<string, Store>();
-const hydrationCallbacks = new Map<string, Array<(store: Store) => void>>();
-const generatorCallbacks = new Map<string, Array<(generator: StoreGenerator) => void>>();
+const storeGeneratorRegistry = new CallbackRegistry<StoreGenerator>();
+const hydratedStoreRegistry = new CallbackRegistry<Store>();
 
 export default {
   /**
@@ -12,7 +11,7 @@ export default {
    */
   register(storeGenerators: { [id: string]: StoreGenerator }): void {
     Object.keys(storeGenerators).forEach(name => {
-      if (registeredStoreGenerators.has(name)) {
+      if (storeGeneratorRegistry.has(name)) {
         console.warn('Called registerStore for store that is already registered', name);
       }
 
@@ -22,13 +21,7 @@ export default {
           `for the store generator with key ${name}.`);
       }
 
-      registeredStoreGenerators.set(name, store);
-
-      const callbacks = generatorCallbacks.get(name) || [];
-      callbacks.forEach(callback => {
-        setTimeout(() => callback(store), 0);
-      });
-      generatorCallbacks.delete(name);
+      storeGeneratorRegistry.set(name, store);
     });
   },
 
@@ -40,11 +33,10 @@ export default {
    * @returns Redux Store, possibly hydrated
    */
   getStore(name: string, throwIfMissing = true): Store | undefined {
-    if (hydratedStores.has(name)) {
-      return hydratedStores.get(name);
-    }
+    const store = hydratedStoreRegistry.get(name);
+    if (store) return store;
 
-    const storeKeys = Array.from(hydratedStores.keys()).join(', ');
+    const storeKeys = Array.from(hydratedStoreRegistry.getAll().keys()).join(', ');
 
     if (storeKeys.length === 0) {
       const msg =
@@ -71,12 +63,10 @@ This can happen if you are server rendering and either:
    * @returns storeCreator with given name
    */
   getStoreGenerator(name: string): StoreGenerator {
-    const registeredStoreGenerator = registeredStoreGenerators.get(name);
-    if (registeredStoreGenerator) {
-      return registeredStoreGenerator;
-    }
+    const generator = storeGeneratorRegistry.get(name);
+    if (generator) return generator;
 
-    const storeKeys = Array.from(registeredStoreGenerators.keys()).join(', ');
+    const storeKeys = Array.from(storeGeneratorRegistry.getAll().keys()).join(', ');
     throw new Error(`Could not find store registered with name '${name}'. Registered store ` +
       `names include [ ${storeKeys} ]. Maybe you forgot to register the store?`);
   },
@@ -87,101 +77,65 @@ This can happen if you are server rendering and either:
    * @param store (not the storeGenerator, but the hydrated store)
    */
   setStore(name: string, store: Store): void {
-    hydratedStores.set(name, store);
-    
-    const callbacks = hydrationCallbacks.get(name) || [];
-    callbacks.forEach(callback => {
-      setTimeout(() => callback(store), 0);
-    });
-    hydrationCallbacks.delete(name);
+    hydratedStoreRegistry.set(name, store);
   },
 
   /**
    * Internally used function to completely clear hydratedStores Map.
    */
   clearHydratedStores(): void {
-    hydratedStores.clear();
+    hydratedStoreRegistry.clear();
   },
 
   /**
    * Get a Map containing all registered store generators. Useful for debugging.
    * @returns Map where key is the component name and values are the store generators.
    */
   storeGenerators(): Map<string, StoreGenerator> {
-    return registeredStoreGenerators;
+    return storeGeneratorRegistry.getAll();
   },
 
   /**
    * Get a Map containing all hydrated stores. Useful for debugging.
    * @returns Map where key is the component name and values are the hydrated stores.
    */
   stores(): Map<string, Store> {
-    return hydratedStores;
+    return hydratedStoreRegistry.getAll();
   },
 
   /**
    * Register a callback to be called when a specific store is hydrated
    * @param storeName Name of the store to watch for
    * @param callback Function called with the store when hydrated
    */
-  onStoreHydrated(
-    storeName: string,
-    callback: (store: Store) => void
-  ): void {
-    // If store is already hydrated, schedule callback
-    const existingStore = hydratedStores.get(storeName);
-    if (existingStore) {
-      setTimeout(() => callback(existingStore), 0);
-      return;
-    }
-
-    // Store callback for future hydration
-    const callbacks = hydrationCallbacks.get(storeName) || [];
-    callbacks.push(callback);
-    hydrationCallbacks.set(storeName, callbacks);
+  onStoreHydrated(storeName: string, callback: ItemRegistrationCallback<Store>): void {
+    hydratedStoreRegistry.onItemRegistered(storeName, callback);
   },
 
   /**
    * Used by components to get the hydrated store, waiting for it to be hydrated if necessary.
    * @param name Name of the store to wait for
    * @returns Promise that resolves with the Store once hydrated
    */
-  async getOrWaitForStore(name: string): Promise<Store> {
-    return new Promise((resolve) => {
-      this.onStoreHydrated(name, resolve);
-    });
+  getOrWaitForStore(name: string): Promise<Store> {
+    return hydratedStoreRegistry.getOrWaitForItem(name);
   },
 
   /**
    * Register a callback to be called when a specific store generator is registered
    * @param storeName Name of the store generator to watch for
    * @param callback Function called with the store generator when registered
    */
-  onStoreGeneratorRegistered(
-    storeName: string,
-    callback: (generator: StoreGenerator) => void
-  ): void {
-    // If generator is already registered, schedule callback
-    const existingGenerator = registeredStoreGenerators.get(storeName);
-    if (existingGenerator) {
-      setTimeout(() => callback(existingGenerator), 0);
-      return;
-    }
-
-    // Store callback for future registration
-    const callbacks = generatorCallbacks.get(storeName) || [];
-    callbacks.push(callback);
-    generatorCallbacks.set(storeName, callbacks);
+  onStoreGeneratorRegistered(storeName: string, callback: ItemRegistrationCallback<StoreGenerator>): void {
+    storeGeneratorRegistry.onItemRegistered(storeName, callback);
   },
 
   /**
    * Used by components to get the store generator, waiting for it to be registered if necessary.
    * @param name Name of the store generator to wait for
    * @returns Promise that resolves with the StoreGenerator once registered
    */
-  async getOrWaitForStoreGenerator(name: string): Promise<StoreGenerator> {
-    return new Promise((resolve) => {
-      this.onStoreGeneratorRegistered(name, resolve);
-    });
+  getOrWaitForStoreGenerator(name: string): Promise<StoreGenerator> {
+    return storeGeneratorRegistry.getOrWaitForItem(name);
   },
 };

node_package/src/types/index.ts

@@ -107,7 +107,7 @@ export interface RegisteredComponent {
   isRenderer: boolean;
 }
 
-export type ComponentRegistrationCallback = (component: RegisteredComponent) => void;
+export type ItemRegistrationCallback<T> = (component: T) => void;
 
 interface Params {
   props?: Record<string, unknown>;