@carbonorm/carbonreact 4.0.10 → 4.0.12

package/dist/CarbonReact.d.ts

@@ -23,6 +23,7 @@ declare abstract class CarbonReact<P = {}, S extends iCarbonReactState = iCarbon
     websocket?: Omit<iCarbonWebSocketProps<P, S>, "instance"> | false;
 } & P, S> {
     private static persistentStateMap;
+    private static activeInstances;
     context: Context<S & iCarbonReactState>;
     protected target: typeof CarbonReact;
     protected static _instance: ThisType<CarbonReact<any, any>>;
@@ -41,9 +42,11 @@ declare abstract class CarbonReact<P = {}, S extends iCarbonReactState = iCarbon
         children?: ReactNode | ReactNode[];
         shouldStatePersist?: boolean | undefined;
         websocket?: boolean | iCarbonWebSocketProps<P, S> | undefined;
+        instanceId?: string;
     } & P);
     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/index.cjs.js

@@ -4361,10 +4361,9 @@ function isJsonString(str) {
 }
 class CarbonReact extends react.Component {
     static persistentStateMap = new Map();
-    // Context is for functional components to access the state of this class efficiently
+    static activeInstances = new Map();
     context = react.createContext(this.state);
     target;
-    // @link https://stackoverflow.com/questions/55029032/what-is-typescripts-thistype-used-for
     static _instance;
     static getInstance() {
         return this._instance;
@@ -4375,7 +4374,6 @@ class CarbonReact extends react.Component {
     static set instance(instance) {
         this._instance = instance;
     }
-    // these are public but the class is abstract
     updateRestfulObjectArrays = (rest) => updateRestfulObjectArrays({
         instance: this,
         ...rest
@@ -4385,40 +4383,35 @@ class CarbonReact extends react.Component {
         ...rest
     });
     static lastLocation = window.location.pathname;
-    // @link https://github.com/welldone-software/why-did-you-render
-    // noinspection JSUnusedGlobalSymbols
     static whyDidYouRender = true;
     constructor(props) {
         super(props);
-        this.target = new.target;
+        const target = new.target;
+        const identifier = props.instanceId || target.name;
+        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.`);
+        }
+        CarbonReact.activeInstances.set(identifier, this);
+        this.target = target;
         console.log('CarbonORM TSX CONSTRUCTOR');
-        // this is the magic that allows each class that's extends this to have a static instance - a singleton pattern
-        // new.target is a meta-property introduced in ES6 that references the constructor that was directly invoked with the new keyword.
-        Object.assign(new.target, {
+        Object.assign(target, {
             _instance: this
         });
-        if (this.props.instanceId && CarbonReact.persistentStateMap.has(this.props.instanceId)) {
-            this.state = CarbonReact.persistentStateMap.get(this.props.instanceId);
+        if (CarbonReact.persistentStateMap.has(identifier)) {
+            this.state = CarbonReact.persistentStateMap.get(identifier);
         }
         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;
         }
-        /** 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.
-         * Children, if not faced with a local storage or other complexity should be a functional component. Functional
-         * components' tend to be shorter syntactically and bonus points if it's stateless.
-         **/
+        // Save the initial state to the persistent state map with the identifier
+        CarbonReact.persistentStateMap.set(identifier, this.state);
     }
     shouldComponentUpdate(nextProps, nextState, _nextContext) {
-        if (this.props.instanceId) {
-            CarbonReact.persistentStateMap.set(this.props.instanceId, nextState);
-        }
+        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;
@@ -4445,6 +4438,10 @@ 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 }) => {