@carbonorm/carbonreact 4.0.14 → 4.0.15

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@carbonorm/carbonreact",
   "license": "MIT",
-  "version": "4.0.14",
+  "version": "4.0.15",
   "browser": "dist/index.umd.js",
   "module": "dist/index.esm.js",
   "main": "dist/index.cjs.js",

package/src/CarbonReact.tsx

@@ -1,4 +1,3 @@
-import { clearCache } from "@carbonorm/carbonnode";
 import changed from "hoc/changed";
 import { GlobalHistory } from "hoc/GlobalHistory";
 import hexToRgb from "hoc/hexToRgb";
@@ -12,10 +11,7 @@ import CarbonWebSocket, { iCarbonWebSocketProps } from "./components/WebSocket/C
 import updateRestfulObjectArrays, { iUpdateRestfulObjectArrays } from "./hoc/updateRestfulObjectArrays";
 import deleteRestfulObjectArrays, { iDeleteRestfulObjectArrays } from "./hoc/deleteRestfulObjectArrays";
 
-
-export type tStatefulApiData<T extends {
-    [key: string]: any
-} = {}> = T[] | undefined | null;
+export type tStatefulApiData<T extends { [key: string]: any } = {}> = T[] | undefined | null;
 
 // our central container, single page application
 export interface iCarbonReactState {
@@ -51,10 +47,11 @@ export function isJsonString(str: string) {
 abstract class CarbonReact<P = {}, S extends iCarbonReactState = iCarbonReactState> extends Component<{
     children?: ReactNode | ReactNode[],
     instanceId?: string,
+    persistentState?: boolean,
     websocket?: Omit<iCarbonWebSocketProps<P, S>, "instance"> | false
 } & P, S> {
 
-    private static persistentStateMap = new Map<string, { [key: string]: any; }>();
+    private static allInstances = new Map<string, CarbonReact<any, any>>();
     private static activeInstances = new Map<string, CarbonReact<any, any>>();
 
     context: Context<S & iCarbonReactState> = createContext(this.state);
@@ -62,12 +59,28 @@ abstract class CarbonReact<P = {}, S extends iCarbonReactState = iCarbonReactSta
 
     protected static _instance: ThisType<CarbonReact<any, any>>;
 
-    static getInstance<T extends CarbonReact<any, any>>(): T {
+    static getInstance<T extends CarbonReact<any, any>>(instanceId?: string): T {
+
+        const identifier = this.generateIdentifier(instanceId);
+
+        if (undefined !== instanceId) {
+            if (CarbonReact.activeInstances.has(identifier)) {
+                return CarbonReact.activeInstances.get(identifier) as T;
+            }
+            throw new Error(`No instance has been instantiated yet for class (${this.name}) with instanceId (${instanceId})`);
+        }
+
+        if (!this._instance) {
+            throw new Error(`No instance has been instantiated yet for class (${this.name})`);
+        }
+
         return this._instance as T;
     }
+
     static get instance() {
         return this.getInstance();
     }
+
     static set instance(instance: CarbonReact<any, any>) {
         this._instance = instance;
     }
@@ -90,39 +103,50 @@ abstract class CarbonReact<P = {}, S extends iCarbonReactState = iCarbonReactSta
 
     protected constructor(props: {
         children?: ReactNode | ReactNode[];
-        shouldStatePersist?: boolean | undefined;
         websocket?: boolean | iCarbonWebSocketProps<P, S> | undefined;
         instanceId?: string; // Optional instanceId from props
+        persistentState?: boolean; // Optional persistentState from props
     } & P) {
         super(props);
 
-        const target = new.target as typeof CarbonReact;
-        const identifier = props.instanceId || target.name;
+        const identifier = this.generateIdentifier();
 
         if (CarbonReact.activeInstances.has(identifier)) {
-            throw new Error(`Instance with ID ${identifier} already exists! CarbonReact extended classes can only be referenced once in DOM with the same identifier.`);
+            throw new Error(`${identifier} instance already exists in the DOM! Each instance should have a unique instanceId.`);
         }
 
+        // Register the new instance
         CarbonReact.activeInstances.set(identifier, this);
 
-        this.target = target;
+        if (props.persistentState && CarbonReact.allInstances.has(identifier)) {
+            // Reuse the state from the existing instance
+            this.state = CarbonReact.allInstances.get(identifier)!.state as S & iCarbonReactState;
+        } else {
+            this.state = initialCarbonReactState as unknown as S & iCarbonReactState;
+            CarbonReact.allInstances.set(identifier, this);
+        }
+
+        this.target = new.target;
         console.log('CarbonORM TSX CONSTRUCTOR');
 
-        Object.assign(target, {
+        Object.assign(this.target, {
             _instance: this
         });
+    }
 
-        if (CarbonReact.persistentStateMap.has(identifier)) {
-            this.state = CarbonReact.persistentStateMap.get(identifier) as S & iCarbonReactState;
-        } else {
-            clearCache({
-                ignoreWarning: true
-            });
-            this.state = initialCarbonReactState as unknown as S & iCarbonReactState;
-        }
+    private static generateIdentifier(instanceId?: string): string {
+        const className = this.name;
+        return instanceId ? `${className}-${instanceId}` : className;
+    }
+
+    private generateIdentifier(): string {
+        const className = (this.constructor as typeof CarbonReact).name;
+        return this.props.instanceId ? `${className}-${this.props.instanceId}` : className;
+    }
 
-        // Save the initial state to the persistent state map with the identifier
-        CarbonReact.persistentStateMap.set(identifier, this.state);
+    componentWillUnmount() {
+        const identifier = this.generateIdentifier();
+        CarbonReact.activeInstances.delete(identifier);
     }
 
     shouldComponentUpdate(
@@ -130,9 +154,6 @@ abstract class CarbonReact<P = {}, S extends iCarbonReactState = iCarbonReactSta
         nextState: Readonly<S>,
         _nextContext: any): boolean {
 
-        const identifier = this.props.instanceId || (this.constructor as typeof CarbonReact).name;
-        CarbonReact.persistentStateMap.set(identifier, nextState);
-
         changed(this.constructor.name + ' (C6Api)', 'props', this.props, nextProps);
         changed(this.constructor.name + ' (C6Api)', 'state', this.state, nextState);
 
@@ -179,11 +200,6 @@ abstract class CarbonReact<P = {}, S extends iCarbonReactState = iCarbonReactSta
             <ToastContainer />
         </>;
     }
-
-    componentWillUnmount() {
-        const identifier = this.props.instanceId || (this.constructor as typeof CarbonReact).name;
-        CarbonReact.activeInstances.delete(identifier);
-    }
 }
 
 export default CarbonReact;