@carbonorm/carbonreact 4.0.14 → 4.0.16

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@carbonorm/carbonreact",
   "license": "MIT",
-  "version": "4.0.14",
+  "version": "4.0.16",
   "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,23 +47,40 @@ 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 activeInstances = new Map<string, CarbonReact<any, any>>();
+    private static allInstances = new Map<string, CarbonReact<any, any>>();
 
     context: Context<S & iCarbonReactState> = createContext(this.state);
     protected target: typeof CarbonReact;
 
     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.allInstances.has(identifier)) {
+                return CarbonReact.allInstances.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,38 @@ 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.`);
+        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);
         }
 
-        CarbonReact.activeInstances.set(identifier, this);
-
-        this.target = target;
+        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;
+    }
 
-        // Save the initial state to the persistent state map with the identifier
-        CarbonReact.persistentStateMap.set(identifier, this.state);
+    private generateIdentifier(): string {
+        const className = (this.constructor as typeof CarbonReact).name;
+        return this.props.instanceId ? `${className}-${this.props.instanceId}` : className;
     }
 
     shouldComponentUpdate(
@@ -130,9 +142,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 +188,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;