@carbonorm/carbonreact 3.6.2 → 4.0.0

package/src/hoc/updateRestfulObjectArrays.tsx

@@ -1,7 +1,6 @@
-import {tRestfulObjectArrayValues, tStatefulApiData} from "variables/C6";
-import CarbonReact from "CarbonReact";
-import {KeysMatching} from "./KeysMatching";
-
+import CarbonReact, { iCarbonReactState, tStatefulApiData } from "CarbonReact";
+import { KeysMatching } from "./KeysMatching";
+import { SubsetMatching } from "./SubsetMatching";
 
 export enum eUpdateInsertMethod {
     REPLACE,
@@ -9,123 +8,124 @@ export enum eUpdateInsertMethod {
     LAST,
 }
 
+export interface iUpdateRestfulObjectArrays<
+    ObjectType extends {
+        [key: string]: any;
+    } = {},
+    S extends { [key: string]: any; } = CarbonReact['state'],
+    P =  CarbonReact['props']
+> {
+    instance: CarbonReact<P, S>;
+    dataOrCallback: ObjectType[] | ((state: Readonly<S>, props: Readonly<P>) => ObjectType[] | null);
+    stateKey: KeysMatching<S, tStatefulApiData<ObjectType>>;
+    uniqueObjectId: keyof ObjectType | (keyof ObjectType)[];
+    insertUpdateOrder: eUpdateInsertMethod;
+    callback?: () => void;
+}
+
 /**
- *
- *                  merged with existing objects.uniqueObjectId || {}.
- * @param dataOrCallback
- * @param uniqueObjectId - the uniqueObjectId of the object to update; typically the primary key of the table.
- * @param stateKey -
- * @param insertUpdateOrder
- * @param callback - if you want to do something with the updated state, you can pass a callback here. Run as the second
- *  parameter of setState.
+ * Updates or inserts objects in a stateful array, merging new data with existing objects.
+ * @param instance - The React component instance.
+ * @param dataOrCallback - Array of objects or a callback function returning an array of objects.
+ * @param stateKey - The key in the state where the data array is stored.
+ * @param uniqueObjectId - The unique identifier(s) for objects, typically the primary key of the table.
+ * @param insertUpdateOrder - The order in which new data should be inserted/updated.
+ * @param callback - Optional callback function to run after state update.
  */
-export default function updateRestfulObjectArrays<ObjectType = tRestfulObjectArrayValues, S = typeof CarbonReact.instance.state, P = typeof CarbonReact.instance.props>
-(dataOrCallback: ObjectType[] | (<K extends keyof S>(
-     state: ((prevState: Readonly<S>, props: Readonly<P>) => (Pick<S, K> | S | null)) | (Pick<S, K> | S | null),
-     callback?: () => void
- ) => null|(ObjectType[])),
- stateKey: KeysMatching<S, tStatefulApiData<ObjectType>>,
- uniqueObjectId: (keyof ObjectType) | (keyof ObjectType)[],
- insertUpdateOrder: eUpdateInsertMethod = eUpdateInsertMethod.LAST,
- callback?: () => void): void {
-
-    const uniqueObjectIds = uniqueObjectId instanceof Array ? uniqueObjectId : [uniqueObjectId];
-
-    const bootstrap = CarbonReact.instance;
-
-    return bootstrap.setState((previousBootstrapState, props): {} => {
+export default function updateRestfulObjectArrays<
+    ObjectType extends {
+        [key: string]: any;
+    } = {},
+    S extends { [key: string]: any; } = CarbonReact['state'],
+    P  = CarbonReact['props']
+>({
+      instance,
+      dataOrCallback,
+      stateKey,
+      uniqueObjectId,
+      insertUpdateOrder = eUpdateInsertMethod.LAST,
+      callback,
+  }: iUpdateRestfulObjectArrays<ObjectType, S, P>): void {
 
-        let newOrReplacementData: null|(ObjectType[]) = [];
+    const uniqueObjectIds = Array.isArray(uniqueObjectId) ? uniqueObjectId : [uniqueObjectId];
 
-        if (dataOrCallback instanceof Array) {
+    type ValidObject = SubsetMatching<S & iCarbonReactState, tStatefulApiData<ObjectType>>;
 
-            newOrReplacementData = dataOrCallback
+    instance.setState((
+            previousBootstrapState: Readonly<S & iCarbonReactState>,
+            props: Readonly<P>
+        ): Pick<S & iCarbonReactState, keyof S> | null => {
 
-        } else if (dataOrCallback instanceof Function) {
+        let newOrReplacementData: ObjectType[] | null = [];
 
-            newOrReplacementData = dataOrCallback(previousBootstrapState, props);
+            if (Array.isArray(dataOrCallback)) {
 
-        } else {
+                newOrReplacementData = dataOrCallback;
 
-            throw Error('The dataOrCallback parameter was not an array or function')
+            } else if (typeof dataOrCallback === "function") {
 
-        }
+                newOrReplacementData = dataOrCallback(previousBootstrapState, props);
 
-        const findUniqueObjectIds = (item : ObjectType, value: ObjectType) => {
+            } else {
 
-            let isMatch = true;
+                throw new Error("The dataOrCallback parameter must be an array or function");
 
-            uniqueObjectIds.find(uniqueObjectId => {
-
-                if (value[uniqueObjectId] !== item[uniqueObjectId]) {
-
-                    isMatch = false;
-
-                    return true;
+            }
 
-                }
+            if (newOrReplacementData === null) {
+                return null
+            }
 
-                return false;
+            const findUniqueObjectIds = (item: ObjectType, value: ObjectType) => {
+                return uniqueObjectIds.every((id) => item[id] === value[id]);
+            };
 
-            })
+            const previousStateProperty = previousBootstrapState[stateKey] as tStatefulApiData<ObjectType> ?? [];
 
-            return isMatch;
+            let updatedData: tStatefulApiData<ObjectType> = newOrReplacementData.map((value) => {
+                const existingObject = previousStateProperty?.find((item) =>
+                    findUniqueObjectIds(item, value)
+                ) || {};
+                return { ...existingObject, ...value };
+            });
 
-        }
+            const filterOutUpdated = (array: tStatefulApiData<ObjectType>) => {
+                return array?.filter((item) => !updatedData.some((value) => findUniqueObjectIds(item, value))) ?? [];
+            };
 
-        const previousStateProperty : ObjectType[] = previousBootstrapState[stateKey];
+            let newState: Partial<ValidObject> = {};
 
-        let updatedData : ObjectType[] = newOrReplacementData?.map(value => {
-            return {
-                ...previousStateProperty?.find(previousValue => findUniqueObjectIds(previousValue, value)) || {},
-                ...value
-            }
-        }) ?? [];
-
-        switch (insertUpdateOrder) {
-            default:
-                throw Error('The insertUpdateOrder (eUpdateInsertMethod) was not implemented')
-            case eUpdateInsertMethod.LAST:
-                return {
-                    [stateKey]: null === newOrReplacementData ? null : [
+            switch (insertUpdateOrder) {
+                case eUpdateInsertMethod.LAST:
+                    newState[stateKey as keyof ValidObject] = [
+                        ...filterOutUpdated(previousStateProperty),
                         ...updatedData,
-                        ...(previousStateProperty?.filter(item => false === (updatedData?.find(value => findUniqueObjectIds(item, value)) || false)) ?? [])
-                    ]
-                }
-
-            case eUpdateInsertMethod.FIRST:
-                return {
-                    [stateKey]: null === newOrReplacementData ? null : [
-                        ...(previousStateProperty?.filter(item => false === (updatedData?.find(value => findUniqueObjectIds(item, value)) || false)) ?? []),
+                    ] as any;
+                    break;
+                case eUpdateInsertMethod.FIRST:
+                    newState[stateKey as keyof ValidObject] = [
                         ...updatedData,
-                    ]
-                }
-            case eUpdateInsertMethod.REPLACE: {
-
-                return {
-                    [stateKey]: [
-                        ...(previousStateProperty?.map(oldObject => {
-
-                            const index = updatedData.findIndex(item => findUniqueObjectIds(item, oldObject));
-
-                            if (-1 === index) {
-
-                                return oldObject
-
+                        ...filterOutUpdated(previousStateProperty),
+                    ] as any;
+                    break;
+                case eUpdateInsertMethod.REPLACE:
+                    newState[stateKey as keyof ValidObject] = [
+                        ...(previousStateProperty?.map((oldObject) => {
+                            const index = updatedData.findIndex((item) => findUniqueObjectIds(item, oldObject));
+                            if (index !== -1) {
+                                return updatedData.splice(index, 1)[0];
                             }
-
-                            return updatedData.splice(index, 1).pop()
-
+                            return oldObject;
                         }) ?? []),
-                        ...updatedData
-                    ]
-                };
+                        ...updatedData,
+                    ] as any;
+                    break;
+                default:
+                    throw new Error("The insertUpdateOrder (eUpdateInsertMethod) was not implemented");
             }
 
-        }
-
-    }, callback);
-
+            return newState as Pick<S & iCarbonReactState, keyof S>;
+        },
+        callback
+    );
 }
-
-

package/src/index.ts

@@ -29,6 +29,7 @@ export { default as CarbonWebSocket } from "./components/WebSocket/CarbonWebSock
 export * from "./components/WebSocket/CarbonWebSocket";
 export * from "./hoc/GlobalHistory";
 export * from "./hoc/KeysMatching";
+export * from "./hoc/SubsetMatching";
 export { default as addValidSQL } from "./hoc/addValidSQL";
 export * from "./hoc/addValidSQL";
 export { default as changed } from "./hoc/changed";

package/src/variables/C6.tsx

@@ -3226,7 +3226,7 @@ export type RestTableInterfaces = iCarbons
     | iWp_Users;
 
 
-export type tStatefulApiData<T> = T[] | undefined | null;
+
 
 
 // this refers to the value types of the keys above, aka values in the state