fix: implement singleton pattern for SharedValuesManager to manage multiple instances but unique per usage key.

Author: HichemTab-tech

src/SharedValuesManager.ts

@@ -7,7 +7,16 @@ export const staticStores: SharedCreated[] = [];
 export class SharedValuesManager<T> {
     data = new Map<string, SharedValue<T>>();
 
-    constructor(protected defaultValue: () => T = () => null as T) {
+    static INSTANCES = new Map<string, SharedValuesManager<any>>();
+
+    private constructor(protected defaultValue: () => T = () => null as T) {
+    }
+
+    static getInstance<T>(instanceKey: string): SharedValuesManager<T> {
+        if (!SharedValuesManager.INSTANCES.has(instanceKey)) {
+            SharedValuesManager.INSTANCES.set(instanceKey, new SharedValuesManager());
+        }
+        return SharedValuesManager.INSTANCES.get(instanceKey) as SharedValuesManager<T>;
     }
 
     addListener(key: string, prefix: Prefix, listener: AFunction) {
@@ -198,10 +207,12 @@ export class SharedValuesApi<T> {
         }
     }
 
+    // noinspection JSUnusedGlobalSymbols
     clearAll() {
         this.sharedData.clearAll();
     }
 
+    // noinspection JSUnusedGlobalSymbols
     clearScope(scopeName?: Prefix) {
         const prefixToSearch: Prefix = scopeName || "_global";
         this.sharedData.data.forEach((_, key) => {
@@ -213,11 +224,13 @@ export class SharedValuesApi<T> {
         });
     }
 
+    // noinspection JSUnusedGlobalSymbols
     resolve(sharedCreated: SharedCreated): T | undefined {
         const {key, prefix} = sharedCreated;
         return this.get(key, prefix);
     }
 
+    // noinspection JSUnusedGlobalSymbols
     clear(key: string, scopeName: Prefix): void;
     clear(sharedCreated: SharedCreated): void;
     clear(key: string | SharedCreated, scopeName?: Prefix) {
@@ -233,11 +246,13 @@ export class SharedValuesApi<T> {
         this.sharedData.clear(keyStr, prefixStr);
     }
 
+    // noinspection JSUnusedGlobalSymbols
     has(key: string, scopeName: Prefix = "_global"): boolean {
         const prefix: Prefix = scopeName || "_global";
         return !!this.sharedData.has(key, prefix);
     }
 
+    // noinspection JSUnusedGlobalSymbols
     getAll(): Record<string, Record<string, T>> {
         const all: Record<string, Record<string, any>> = {};
         this.sharedData.data.forEach((value, key) => {

src/hooks/use-shared-function.ts

@@ -10,7 +10,7 @@ export type SharedFunctionValue<T> = {
     error?: unknown;
 }
 
-const sharedFunctionsManager = new SharedValuesManager<SharedFunctionValue<any>>();
+const sharedFunctionsManager = SharedValuesManager.getInstance<SharedFunctionValue<any>>("SharedFunctionValue");
 export const sharedFunctionsApi = new SharedValuesApi<SharedFunctionValue<any>>(sharedFunctionsManager);
 
 interface SharedFunctionCreated<T, Args extends unknown[]> extends SharedCreated {

src/hooks/use-shared-state.ts

@@ -5,7 +5,7 @@ import useShared from "./use-shared";
 import {ensureNonEmptyString} from "../lib/utils";
 import isEqual from "react-fast-compare";
 
-const sharedStatesManager = new SharedValuesManager<any>();
+const sharedStatesManager = SharedValuesManager.getInstance<any>("sharedStatesManager");
 export const sharedStatesApi = new SharedValuesApi<any>(sharedStatesManager);
 
 export interface SharedStateCreated<T> extends SharedCreated {

src/hooks/use-shared-subscription.ts

@@ -24,7 +24,7 @@ interface SharedSubscription<T> extends SharedSubscriptionValue<T> {
     unsubscribe?: Unsubscribe | void;
 }
 
-const sharedSubscriptionsManager = new SharedValuesManager<SharedSubscription<any>>();
+const sharedSubscriptionsManager = SharedValuesManager.getInstance<SharedSubscription<any>>("SharedSubscription");
 export const sharedSubscriptionsApi = new SharedValuesApi<SharedSubscription<any>>(sharedSubscriptionsManager);
 
 interface SharedSubscriptionCreated<T> extends SharedCreated {