@carbonorm/carbonreact 3.6.1 → 3.6.2

package/dist/CarbonReact.d.ts

@@ -12,65 +12,27 @@ export interface iCarbonReactState {
 export declare const initialRequiredCarbonORMState: iCarbonReactState;
 export declare const initialCarbonReactState: iCarbonReactState & iRestfulObjectArrayTypes;
 export declare function isJsonString(str: string): boolean;
-declare const CarbonReact: {
-    new <P = {}, S = {}>(props: any): {
-        context: Context<S & iCarbonReactState>;
-        shouldComponentUpdate(nextProps: Readonly<any>, nextState: Readonly<iCarbonReactState>, _nextContext: any): boolean;
-        componentDidUpdate(_prevProps: Readonly<any>, _prevState: Readonly<iCarbonReactState>, _snapshot?: any): void;
-        render(): ReactElement;
-        setState<K extends keyof iCarbonReactState | keyof S>(state: (S & iCarbonReactState) | ((prevState: Readonly<S & iCarbonReactState>, props: Readonly<{
-            children?: ReactNode | ReactNode[];
-            shouldStatePersist?: boolean | undefined;
-            websocket?: boolean | iCarbonWebSocketProps | undefined;
-        } & P>) => (S & iCarbonReactState) | Pick<S & iCarbonReactState, K> | null) | Pick<S & iCarbonReactState, K> | null, callback?: (() => void) | undefined): void;
-        forceUpdate(callback?: (() => void) | undefined): void;
-        readonly props: Readonly<{
-            children?: ReactNode | ReactNode[];
-            shouldStatePersist?: boolean | undefined;
-            websocket?: boolean | iCarbonWebSocketProps | undefined;
-        } & P>;
-        state: Readonly<S & iCarbonReactState>;
-        refs: {
-            [key: string]: import("react").ReactInstance;
-        };
-        componentDidMount?(): void;
-        componentWillUnmount?(): void;
-        componentDidCatch?(error: Error, errorInfo: import("react").ErrorInfo): void;
-        getSnapshotBeforeUpdate?(prevProps: Readonly<{
-            children?: ReactNode | ReactNode[];
-            shouldStatePersist?: boolean | undefined;
-            websocket?: boolean | iCarbonWebSocketProps | undefined;
-        } & P>, prevState: Readonly<S & iCarbonReactState>): any;
-        componentWillMount?(): void;
-        UNSAFE_componentWillMount?(): void;
-        componentWillReceiveProps?(nextProps: Readonly<{
-            children?: ReactNode | ReactNode[];
-            shouldStatePersist?: boolean | undefined;
-            websocket?: boolean | iCarbonWebSocketProps | undefined;
-        } & P>, nextContext: any): void;
-        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<{
-            children?: ReactNode | ReactNode[];
-            shouldStatePersist?: boolean | undefined;
-            websocket?: boolean | iCarbonWebSocketProps | undefined;
-        } & P>, nextContext: any): void;
-        componentWillUpdate?(nextProps: Readonly<{
-            children?: ReactNode | ReactNode[];
-            shouldStatePersist?: boolean | undefined;
-            websocket?: boolean | iCarbonWebSocketProps | undefined;
-        } & P>, nextState: Readonly<S & iCarbonReactState>, nextContext: any): void;
-        UNSAFE_componentWillUpdate?(nextProps: Readonly<{
-            children?: ReactNode | ReactNode[];
-            shouldStatePersist?: boolean | undefined;
-            websocket?: boolean | iCarbonWebSocketProps | undefined;
-        } & P>, nextState: Readonly<S & iCarbonReactState>, nextContext: any): void;
-    };
-    instance: Component<{
+declare abstract class CarbonReact<P = {}, S = {}> extends Component<{
+    children?: ReactNode | ReactNode[];
+    instanceId?: string;
+    websocket?: iCarbonWebSocketProps | boolean;
+} & P, S & iCarbonReactState> {
+    context: Context<S & iCarbonReactState>;
+    protected static instance: CarbonReact & Component<{
         children?: ReactNode | ReactNode[];
     } & any, any & iCarbonReactState>;
-    persistentState?: iCarbonReactState | undefined;
-    lastLocation: string;
-    whyDidYouRender: boolean;
-    getState<S_1>(): S_1;
-    contextType?: Context<any> | undefined;
-};
+    protected static getState(): Readonly<iCarbonReactState> & Readonly<any>;
+    protected static useContext(): () => iCarbonReactState;
+    protected: any;
+    static lastLocation: string;
+    static whyDidYouRender: boolean;
+    protected constructor(props: {
+        children?: ReactNode | ReactNode[];
+        shouldStatePersist?: boolean | undefined;
+        websocket?: boolean | iCarbonWebSocketProps | undefined;
+    } & P);
+    shouldComponentUpdate(nextProps: Readonly<any>, nextState: Readonly<iCarbonReactState>, _nextContext: any): boolean;
+    componentDidUpdate(_prevProps: Readonly<any>, _prevState: Readonly<iCarbonReactState>, _snapshot?: any): void;
+    render(): ReactElement;
+}
 export default CarbonReact;

package/dist/index.cjs.js

@@ -4257,10 +4257,18 @@ function isJsonString(str) {
     return true;
 }
 // Create a context
-const CarbonReact = class extends react.Component {
-    static instance;
+const persistentStateMap = new Map();
+class CarbonReact extends react.Component {
     context = react.createContext(this.state);
-    static persistentState = undefined;
+    // Private static member
+    static instance;
+    static getState() {
+        return CarbonReact.instance.state;
+    }
+    static useContext() {
+        return () => react.useContext(CarbonReact.instance.context);
+    }
+    protected;
     static lastLocation = window.location.pathname;
     // @link https://github.com/welldone-software/why-did-you-render
     // noinspection JSUnusedGlobalSymbols
@@ -4268,16 +4276,20 @@ const CarbonReact = class extends react.Component {
     constructor(props) {
         super(props);
         console.log('CarbonORM TSX CONSTRUCTOR');
-        if (CarbonReact.persistentState !== undefined && this.props.shouldStatePersist !== false) {
-            this.state = CarbonReact.persistentState;
+        Object.assign(this, {
+            instance: this
+        });
+        if (this.props.instanceId && persistentStateMap.has(this.props.instanceId)) {
+            this.state = persistentStateMap.get(this.props.instanceId);
         }
         else {
+            // This should only ever be done here, when the full state is being trashed.
+            // todo - does this suck in context of multiple instances?
+            carbonnode.clearCache({
+                ignoreWarning: true
+            });
             this.state = initialCarbonReactState;
         }
-        // This should only ever be done here, when the full state is being trashed.
-        carbonnode.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.
@@ -4285,15 +4297,9 @@ const CarbonReact = class extends react.Component {
          * components' tend to be shorter syntactically and bonus points if it's stateless.
          **/
     }
-    static getState() {
-        return CarbonReact.instance.state;
-    }
     shouldComponentUpdate(nextProps, nextState, _nextContext) {
-        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);
         changed(this.constructor.name + ' (C6Api)', 'state', this.state, nextState);
@@ -4321,7 +4327,7 @@ const CarbonReact = class extends react.Component {
         return jsxRuntime_2(jsxRuntime_3, { children: [jsxRuntime_1(GlobalHistory, {}), this.props.websocket &&
                     jsxRuntime_1(CarbonWebSocket, { ...(true === this.props.websocket ? {} : this.props.websocket) }), jsxRuntime_1(Context, { value: this.state, children: this.props.children }), jsxRuntime_1(reactToastify.ToastContainer, {})] });
     }
-};
+}
 
 var getStatefulObjectWithWhere = ({ request }) => {
     console.log('request', request);