@carbonorm/carbonreact 4.0.13 → 4.0.15

package/dist/CarbonReact.d.ts

@@ -20,14 +20,15 @@ export declare function isJsonString(str: string): boolean;
 declare 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;
+    private static allInstances;
     private static activeInstances;
     context: Context<S & iCarbonReactState>;
     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;
     static get instance(): CarbonReact<any, any>;
     static set instance(instance: CarbonReact<any, any>);
     updateRestfulObjectArrays: <ObjectType extends {
@@ -40,13 +41,15 @@ declare abstract class CarbonReact<P = {}, S extends iCarbonReactState = iCarbon
     static whyDidYouRender: boolean;
     protected constructor(props: {
         children?: ReactNode | ReactNode[];
-        shouldStatePersist?: boolean | undefined;
         websocket?: boolean | iCarbonWebSocketProps<P, S> | undefined;
         instanceId?: string;
+        persistentState?: boolean;
     } & P);
+    private static generateIdentifier;
+    private generateIdentifier;
+    componentWillUnmount(): void;
     shouldComponentUpdate(nextProps: Readonly<P>, nextState: Readonly<S>, _nextContext: any): boolean;
     componentDidUpdate(_prevProps: Readonly<P>, _prevState: Readonly<S>, _snapshot?: any): void;
     render(): ReactElement;
-    componentWillUnmount(): void;
 }
 export default CarbonReact;

package/dist/components/WebSocket/CarbonWebSocket.d.ts

@@ -1,12 +1,11 @@
 import CarbonReact, { iCarbonReactState } from "CarbonReact";
-import { tC6Tables, tC6RestApi } from "@carbonorm/carbonnode";
+import { iC6Object } from "@carbonorm/carbonnode";
 export interface iCarbonWebSocketProps<P, S extends iCarbonReactState> {
     url?: string;
     timeoutSeconds?: number;
     heartbeatSeconds?: number;
     instance: CarbonReact<P, S>;
-    TABLES?: tC6Tables;
-    WsLiveUpdates?: tC6RestApi;
+    C6?: iC6Object;
 }
 /**
  * @function connect

package/dist/index.cjs.js

@@ -1,10 +1,10 @@
 'use strict';
 
 var react = require('react');
-var carbonnode = require('@carbonorm/carbonnode');
 var reactRouterDom = require('react-router-dom');
 var reactToastify = require('react-toastify');
 var OutsideClickHandler = require('react-outside-click-handler');
+var carbonnode = require('@carbonorm/carbonnode');
 var classNames = require('classnames');
 var freeSolidSvgIcons = require('@fortawesome/free-solid-svg-icons');
 var reactFontawesome = require('@fortawesome/react-fontawesome');
@@ -4066,7 +4066,8 @@ const useEffectOnce = (effect) => {
  * This function establishes a connection with the websocket and also ensures constant reconnection if connection closes
  **/
 function initiateWebsocket(props) {
-    let { instance, TABLES = undefined, WsLiveUpdates = undefined, url = 'ws' + (window.location.protocol === 'https:' ? 's' : '') + '://' + window.location.host + '/carbonorm/websocket', timeoutSeconds = 250, heartbeatSeconds = 60 } = props;
+    let { instance, url = 'ws' + (window.location.protocol === 'https:' ? 's' : '') + '://' + window.location.host + '/carbonorm/websocket', timeoutSeconds = 250, heartbeatSeconds = 60, C6 } = props;
+    const { TABLES = undefined, IMPORT = undefined, } = C6 ?? {};
     const { websocket } = instance.state;
     if (!("WebSocket" in window)) {
         // todo - store that this has been shown in the state
@@ -4113,10 +4114,6 @@ function initiateWebsocket(props) {
                     console.log('WebSocket updates without the TABLES property passed will not automatically update the state.');
                     return;
                 }
-                if (undefined === WsLiveUpdates) {
-                    console.log('WebSocket updates without the WsLiveUpdates property passed will not automatically update the state.');
-                    return;
-                }
                 if (parsedData?.REST) {
                     const TABLE_NAME = parsedData?.REST?.TABLE_NAME;
                     const TABLE_PREFIX = parsedData?.REST?.TABLE_PREFIX;
@@ -4138,7 +4135,8 @@ function initiateWebsocket(props) {
                         return;
                     }
                     const primaryKeyKeys = Object.keys(REQUEST_PRIMARY_KEY);
-                    const elementsToUpdate = currentCache.filter((row) => {
+                    // todo - which direction should we filter
+                    const elementsToUpdate = currentCache?.filter((row) => {
                         for (const element of primaryKeyKeys) {
                             // remove the table name from the column name
                             const column = element.split('.')[1];
@@ -4148,7 +4146,7 @@ function initiateWebsocket(props) {
                             }
                         }
                         return true;
-                    });
+                    }) ?? [];
                     console.log('elementsToUpdate', elementsToUpdate);
                     if (elementsToUpdate.length === 0) {
                         console.error('Could not find any elements to update in the cache.', elementsToUpdate, primaryKeyKeys, REQUEST_PRIMARY_KEY, currentCache);
@@ -4160,8 +4158,22 @@ function initiateWebsocket(props) {
                             ...REQUEST
                         };
                     });
-                    updatedElements.forEach((row) => {
-                        WsLiveUpdates[TABLE_NAME_SHORT][METHOD]({}, row);
+                    updatedElements.forEach(async (row) => {
+                        const RestRequests = await IMPORT?.(TABLE_NAME_SHORT);
+                        const { postState, deleteState, putState, } = RestRequests;
+                        switch (METHOD) {
+                            case 'POST':
+                                postState({}, row);
+                                break;
+                            case 'DELETE':
+                                deleteState({}, row);
+                                break;
+                            case 'PUT':
+                                putState({}, row);
+                                break;
+                            default:
+                                console.error('Method not supported', METHOD);
+                        }
                     });
                 }
             });
@@ -4360,12 +4372,22 @@ function isJsonString(str) {
     return true;
 }
 class CarbonReact extends react.Component {
-    static persistentStateMap = new Map();
+    static allInstances = new Map();
     static activeInstances = new Map();
     context = react.createContext(this.state);
     target;
     static _instance;
-    static getInstance() {
+    static getInstance(instanceId) {
+        const identifier = this.generateIdentifier(instanceId);
+        if (undefined !== instanceId) {
+            if (CarbonReact.activeInstances.has(identifier)) {
+                return CarbonReact.activeInstances.get(identifier);
+            }
+            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;
     }
     static get instance() {
@@ -4386,32 +4408,39 @@ class CarbonReact extends react.Component {
     static whyDidYouRender = true;
     constructor(props) {
         super(props);
-        const target = new.target;
-        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;
-        console.log('CarbonORM TSX CONSTRUCTOR');
-        Object.assign(target, {
-            _instance: this
-        });
-        if (CarbonReact.persistentStateMap.has(identifier)) {
-            this.state = CarbonReact.persistentStateMap.get(identifier);
+        if (props.persistentState && CarbonReact.allInstances.has(identifier)) {
+            // Reuse the state from the existing instance
+            this.state = CarbonReact.allInstances.get(identifier).state;
         }
         else {
-            carbonnode.clearCache({
-                ignoreWarning: true
-            });
             this.state = initialCarbonReactState;
+            CarbonReact.allInstances.set(identifier, this);
         }
-        // Save the initial state to the persistent state map with the identifier
-        CarbonReact.persistentStateMap.set(identifier, this.state);
+        this.target = new.target;
+        console.log('CarbonORM TSX CONSTRUCTOR');
+        Object.assign(this.target, {
+            _instance: this
+        });
+    }
+    static generateIdentifier(instanceId) {
+        const className = this.name;
+        return instanceId ? `${className}-${instanceId}` : className;
+    }
+    generateIdentifier() {
+        const className = this.constructor.name;
+        return this.props.instanceId ? `${className}-${this.props.instanceId}` : className;
+    }
+    componentWillUnmount() {
+        const identifier = this.generateIdentifier();
+        CarbonReact.activeInstances.delete(identifier);
     }
     shouldComponentUpdate(nextProps, nextState, _nextContext) {
-        const identifier = this.props.instanceId || this.constructor.name;
-        CarbonReact.persistentStateMap.set(identifier, nextState);
         changed(this.constructor.name + ' (C6Api)', 'props', this.props, nextProps);
         changed(this.constructor.name + ' (C6Api)', 'state', this.state, nextState);
         return true;
@@ -4438,10 +4467,6 @@ class CarbonReact extends react.Component {
         return jsxRuntime_2(jsxRuntime_3, { children: [jsxRuntime_1(GlobalHistory, {}), this.props.websocket &&
                     jsxRuntime_1(CarbonWebSocket, { ...(false !== this.props.websocket ? this.props.websocket : {}), instance: this }), jsxRuntime_1(Context, { value: this.state, children: this.props.children }), jsxRuntime_1(reactToastify.ToastContainer, {})] });
     }
-    componentWillUnmount() {
-        const identifier = this.props.instanceId || this.constructor.name;
-        CarbonReact.activeInstances.delete(identifier);
-    }
 }
 
 var getStatefulObjectWithWhere = ({ request }) => {