@carbonorm/carbonreact 3.6.0 → 3.6.2

package/package.json

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

package/src/CarbonReact.tsx

@@ -2,13 +2,13 @@ import {clearCache} from "@carbonorm/carbonnode";
 import changed from "hoc/changed";
 import {GlobalHistory} from "hoc/GlobalHistory";
 import hexToRgb from "hoc/hexToRgb";
-import {Component, Context, createContext, ReactElement, ReactNode} from 'react';
+import {Component, Context, createContext, useContext, ReactElement, ReactNode} from 'react';
 import {ToastContainer} from 'react-toastify';
 import 'react-toastify/dist/ReactToastify.min.css';
 import BackendThrowable from 'components/Errors/BackendThrowable';
 import Nest from 'components/Nest/Nest';
 import {initialRestfulObjectsState, iRestfulObjectArrayTypes} from "variables/C6";
-import CarbonWebSocket from "./components/WebSocket/CarbonWebSocket";
+import CarbonWebSocket, {iCarbonWebSocketProps} from "./components/WebSocket/CarbonWebSocket";
 
 
 // our central container, single page application
@@ -45,18 +45,30 @@ export function isJsonString(str: string) {
 
 // Create a context
 
-const CarbonReact = class<P = {}, S = {}> extends Component<{
+const persistentStateMap = new Map<string, iCarbonReactState>();
+
+abstract class CarbonReact<P = {}, S = {}> extends Component<{
     children?: ReactNode | ReactNode[],
-    shouldStatePersist?: boolean,
+    instanceId?: string,
+    websocket?: iCarbonWebSocketProps | boolean
 } & P, S & iCarbonReactState> {
 
-    static instance: Component<{
+    context: Context<S & iCarbonReactState> = createContext(this.state);
+
+    // Private static member
+    protected static instance:  CarbonReact & Component<{
         children?: ReactNode | ReactNode[],
     } & any, any & iCarbonReactState>;
 
-    context: Context<S & iCarbonReactState> = createContext(this.state);
+    protected static getState() {
+        return CarbonReact.instance.state;
+    }
+
+    protected static useContext(){
+        return () => useContext(CarbonReact.instance.context);
+    }
 
-    static persistentState?: iCarbonReactState = undefined;
+    protected ;
 
     static lastLocation = window.location.pathname;
 
@@ -64,27 +76,32 @@ const CarbonReact = class<P = {}, S = {}> extends Component<{
     // noinspection JSUnusedGlobalSymbols
     static whyDidYouRender = true;
 
-    constructor(props) {
+    protected constructor(props: { children?: ReactNode | ReactNode[]; shouldStatePersist?: boolean | undefined; websocket?: boolean | iCarbonWebSocketProps | undefined; } & P) {
 
         super(props);
 
         console.log('CarbonORM TSX CONSTRUCTOR');
 
-        if (CarbonReact.persistentState !== undefined && this.props.shouldStatePersist !== false) {
+        Object.assign(this, {
+            instance: this
+        })
 
-            this.state = CarbonReact.persistentState as S & iCarbonReactState;
+        if (this.props.instanceId && persistentStateMap.has(this.props.instanceId)) {
+
+            this.state = persistentStateMap.get(this.props.instanceId) as S & iCarbonReactState;
 
         } else {
 
+            // This should only ever be done here, when the full state is being trashed.
+            // todo - does this suck in context of multiple instances?
+            clearCache({
+                ignoreWarning: true
+            });
+
             this.state = initialCarbonReactState as unknown as S & iCarbonReactState;
 
         }
 
-        // This should only ever be done here, when the full state is being trashed.
-        clearCache({
-            ignoreWarning: true
-        });
-
         /** We can think of our app as having one state; this state.
          * Long-term, I'd like us to store this state to local storage and only load updates on reload...
          * Class based components are far easier to manage state in local storage and pass state down to children.
@@ -94,23 +111,15 @@ const CarbonReact = class<P = {}, S = {}> extends Component<{
 
     }
 
-    static getState<S>(): S {
-        return CarbonReact.instance.state;
-    }
+
 
     shouldComponentUpdate(
         nextProps: Readonly<any>,
         nextState: Readonly<iCarbonReactState>,
         _nextContext: any): boolean {
 
-        if (this.props.shouldStatePersist === false) {
-
-            CarbonReact.persistentState = undefined;
-
-        } else {
-
-            CarbonReact.persistentState = nextState;
-
+        if (this.props.instanceId) {
+            persistentStateMap.set(this.props.instanceId, nextState);
         }
 
         changed(this.constructor.name + ' (C6Api)', 'props', this.props, nextProps);
@@ -132,7 +141,7 @@ const CarbonReact = class<P = {}, S = {}> extends Component<{
         }
     }
 
-    render() : ReactElement {
+    render(): ReactElement {
 
         console.log('CarbonORM TSX RENDER');
 
@@ -155,7 +164,8 @@ const CarbonReact = class<P = {}, S = {}> extends Component<{
 
         return <>
             <GlobalHistory/>
-            <CarbonWebSocket/>
+            {this.props.websocket &&
+                <CarbonWebSocket {...(true === this.props.websocket ? {} : this.props.websocket)} />}
             <Context value={this.state}>
                 {this.props.children}
             </Context>