@carbonorm/carbonreact 3.6.2 → 4.0.1

package/README.md

@@ -48,7 +48,7 @@ ideally once it has mounted it never gets unmounted. In application where this i
 application even if the component is unmounted. The behavior of accessing or updating state while the component is 
 unknown (undefined) and should be avoided. The example below shows a simple implementation of CarbonReact. Our user 
 defined component is in `CarbonORM` which is written to extend the `CarbonReact` class. Your implementation must also 
-extend `CarbonORM`.
+extend `CarbonReact`. The name `CarbonORM` is arbitrary and can be changed to your application's name.
 
 
 [index.tsx](https://github.com/CarbonORM/CarbonORM.dev/blob/www/src/index.tsx)

package/dist/CarbonReact.d.ts

@@ -2,6 +2,11 @@ import { Component, Context, ReactElement, ReactNode } from 'react';
 import 'react-toastify/dist/ReactToastify.min.css';
 import { iRestfulObjectArrayTypes } from "variables/C6";
 import { iCarbonWebSocketProps } from "./components/WebSocket/CarbonWebSocket";
+import { iUpdateRestfulObjectArrays } from "./hoc/updateRestfulObjectArrays";
+import { iDeleteRestfulObjectArrays } from "./hoc/deleteRestfulObjectArrays";
+export type tStatefulApiData<T extends {
+    [key: string]: any;
+} = {}> = T[] | undefined | null;
 export interface iCarbonReactState {
     alertsWaiting: any[];
     websocketEvents: MessageEvent[];
@@ -12,18 +17,22 @@ export interface iCarbonReactState {
 export declare const initialRequiredCarbonORMState: iCarbonReactState;
 export declare const initialCarbonReactState: iCarbonReactState & iRestfulObjectArrayTypes;
 export declare function isJsonString(str: string): boolean;
-declare abstract class CarbonReact<P = {}, S = {}> extends Component<{
+declare abstract class CarbonReact<P = {}, S extends {
+    [key: string]: any;
+} = {}> extends Component<{
     children?: ReactNode | ReactNode[];
     instanceId?: string;
-    websocket?: iCarbonWebSocketProps | boolean;
+    websocket?: Omit<iCarbonWebSocketProps, "instance"> | boolean;
 } & P, S & iCarbonReactState> {
     context: Context<S & iCarbonReactState>;
-    protected static instance: CarbonReact & Component<{
-        children?: ReactNode | ReactNode[];
-    } & any, any & iCarbonReactState>;
-    protected static getState(): Readonly<iCarbonReactState> & Readonly<any>;
-    protected static useContext(): () => iCarbonReactState;
-    protected: any;
+    protected static instance: CarbonReact;
+    protected target: typeof CarbonReact;
+    protected updateRestfulObjectArrays: <ObjectType extends {
+        [key: string]: any;
+    } = {}>(rest: Omit<iUpdateRestfulObjectArrays<ObjectType, S, P>, "instance">) => void;
+    protected deleteRestfulObjectArrays: <ObjectType extends {
+        [key: string]: any;
+    } = {}>(rest: Omit<iDeleteRestfulObjectArrays<ObjectType, S, P>, "instance">) => void;
     static lastLocation: string;
     static whyDidYouRender: boolean;
     protected constructor(props: {

package/dist/components/Alert/Alert.d.ts

@@ -1,3 +1,4 @@
+import CarbonReact from "CarbonReact";
 import { ReactNode } from "react";
 export interface iAlertButtonOptions {
     text: string;
@@ -8,6 +9,7 @@ export interface iAlertButtonOptions {
 export interface iAlert {
     title: string;
     text: string;
+    instance: CarbonReact;
     component?: ReactNode;
     icon?: "warning" | "error" | "success" | "info" | "question" | null;
     buttons?: (iAlertButtonOptions)[] | undefined;
@@ -21,4 +23,6 @@ export interface iAlert {
     };
 }
 export declare function addAlert(props: iAlert): void;
-export default function Alert(): import("react/jsx-runtime").JSX.Element | null;
+export default function Alert({ instance }: {
+    instance: CarbonReact;
+}): import("react/jsx-runtime").JSX.Element | null;

package/dist/components/Errors/BackendThrowable.d.ts

@@ -1,3 +1,6 @@
+import CarbonReact from "../../CarbonReact";
 import { ReactElement } from "react";
-declare const _default: () => ReactElement;
+declare const _default: (props: {
+    instance: CarbonReact;
+}) => ReactElement;
 export default _default;

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

@@ -1,8 +1,10 @@
+import CarbonReact from "CarbonReact";
 import { tC6Tables, tC6RestApi } from "@carbonorm/carbonnode";
 export interface iCarbonWebSocketProps {
     url?: string;
     timeoutSeconds?: number;
     heartbeatSeconds?: number;
+    instance: CarbonReact;
     TABLES?: tC6Tables;
     WsLiveUpdates?: tC6RestApi;
 }
@@ -10,5 +12,5 @@ export interface iCarbonWebSocketProps {
  * @function connect
  * This function establishes a connection with the websocket and also ensures constant reconnection if connection closes
  **/
-export declare function initiateWebsocket({ TABLES, WsLiveUpdates, url, timeoutSeconds, heartbeatSeconds }?: iCarbonWebSocketProps): void;
+export declare function initiateWebsocket(props: iCarbonWebSocketProps): void;
 export default function (props: iCarbonWebSocketProps): null;

package/dist/hoc/KeysMatching.d.ts

@@ -1,3 +1,3 @@
 export type KeysMatching<T, V> = {
-    [K in keyof T]-?: T[K] extends V ? K : never;
+    [K in keyof T]: T[K] extends V ? K : never;
 }[keyof T];

package/dist/hoc/SubsetMatching.d.ts

@@ -0,0 +1,4 @@
+import { KeysMatching } from "./KeysMatching";
+export type SubsetMatching<T extends object, V> = {
+    [K in KeysMatching<T, V>]: T[K];
+};

package/dist/hoc/deleteRestfulObjectArrays.d.ts

@@ -1,4 +1,18 @@
-import CarbonReact from "CarbonReact";
-import { tRestfulObjectArrayValues, tStatefulApiData } from "variables/C6";
+import CarbonReact, { tStatefulApiData } from "CarbonReact";
 import { KeysMatching } from "./KeysMatching";
-export default function deleteRestfulObjectArrays<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)[], callback?: () => void): void;
+export interface iDeleteRestfulObjectArrays<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)[];
+    callback?: () => void;
+}
+export default function deleteRestfulObjectArrays<ObjectType extends {
+    [key: string]: any;
+} = {}, S extends {
+    [key: string]: any;
+} = CarbonReact['state'], P = CarbonReact['props']>({ instance, dataOrCallback, stateKey, uniqueObjectId, callback }: iDeleteRestfulObjectArrays<ObjectType, S, P>): void;

package/dist/hoc/updateRestfulObjectArrays.d.ts

@@ -1,19 +1,33 @@
-import { tRestfulObjectArrayValues, tStatefulApiData } from "variables/C6";
-import CarbonReact from "CarbonReact";
+import CarbonReact, { tStatefulApiData } from "CarbonReact";
 import { KeysMatching } from "./KeysMatching";
 export declare enum eUpdateInsertMethod {
     REPLACE = 0,
     FIRST = 1,
     LAST = 2
 }
+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, callback?: () => void): void;
+export default function updateRestfulObjectArrays<ObjectType extends {
+    [key: string]: any;
+} = {}, S extends {
+    [key: string]: any;
+} = CarbonReact['state'], P = CarbonReact['props']>({ instance, dataOrCallback, stateKey, uniqueObjectId, insertUpdateOrder, callback, }: iUpdateRestfulObjectArrays<ObjectType, S, P>): void;