@jescon-technologies/react-native-ui-kit 0.0.19 → 0.0.21

package/index.d.ts

@@ -23,10 +23,11 @@ export { default as HeaderBlock } from './src/CustomComponents/HeaderBlock';
 export { default as HDashboard } from './src/Hoc/HDashboard';
 export { default as NetworkServiceCall } from './src/Common/NetworkServiceCall';
 export { default as useNotifications } from './src/Handlers/NotificationsContext';
-export { default as ResponseComponentContext, ResponseComponentProvider } from './src/Handlers/ResponseComponentContext';
-export type { ResponseComponentProviderProps, ResponseContextValue, ResponseJSON } from './src/Handlers/ResponseComponentContext';
+export { default as CBackHandler } from './src/CustomComponents/CBackHandler';
+export * from './src/Handlers/ResponseComponentContext';
 export * from './src/Navigation/useNavigation';
 export * from './src/Navigation/useIsFocused';
 export * from './src/Navigation/useFocusEffect';
-export { default as CBackHandler } from './src/CustomComponents/CBackHandler';
 export * from './src/CommonStyle/ComponentFunctions';
+export * from '../../../src/Common/apiConstants'
+export * from '../../../src/Common/Global';

package/index.js

@@ -23,9 +23,11 @@ export { default as HeaderBlock } from './src/CustomComponents/HeaderBlock';
 export { default as HDashboard } from './src/Hoc/HDashboard';
 export { default as NetworkServiceCall } from './src/Common/NetworkServiceCall';
 export { default as useNotifications } from './src/Handlers/NotificationsContext';
-export { default as ResponseComponentContext, ResponseComponentProvider } from './src/Handlers/ResponseComponentContext';
+export { default as CBackHandler } from './src/CustomComponents/CBackHandler';
+export * from './src/Handlers/ResponseComponentContext';
 export * from './src/Navigation/useNavigation';
 export * from './src/Navigation/useIsFocused';
 export * from './src/Navigation/useFocusEffect';
-export { default as CBackHandler } from './src/CustomComponents/CBackHandler';
 export * from './src/CommonStyle/ComponentFunctions';
+export * from '../../../src/Common/apiConstants'
+export * from '../../../src/Common/Global';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jescon-technologies/react-native-ui-kit",
-  "version": "0.0.19",
+  "version": "0.0.21",
   "description": "A React Native module for Jescon Technologies that provides react-native-ui-kit",
   "main": "index.js",
   "types": "index.d.ts",

package/src/Common/GlobalContext.tsx

@@ -0,0 +1,78 @@
+import React, {
+  createContext,
+  useContext,
+  useEffect,
+  useSyncExternalStore,
+} from 'react';
+import type { ReactNode } from 'react';
+
+export type GlobalConfig = Record<string, unknown>;
+
+interface GlobalStore {
+  getSnapshot: () => object;
+  subscribe: (listener: () => void) => () => void;
+}
+
+let globalConfig: object = {};
+const listeners = new Set<() => void>();
+
+const notifyListeners = (): void => {
+  listeners.forEach(listener => listener());
+};
+
+const globalStore: GlobalStore = {
+  getSnapshot: () => globalConfig,
+  subscribe: listener => {
+    listeners.add(listener);
+    return () => listeners.delete(listener);
+  },
+};
+
+export const GlobalContext = createContext<GlobalStore>(globalStore);
+
+export const setGlobal = <T extends object>(config: T): void => {
+  globalConfig = config;
+  notifyListeners();
+};
+
+export const getGlobal = <
+  T extends object = GlobalConfig,
+>(): T => globalConfig as T;
+
+export const updateGlobal = <T extends object = GlobalConfig>(
+  config: Partial<T>,
+): void => {
+  Object.assign(globalConfig, config);
+  notifyListeners();
+};
+
+export const useGlobal = <T extends object = GlobalConfig>(): T => {
+  const store = useContext(GlobalContext);
+  return useSyncExternalStore(
+    store.subscribe,
+    store.getSnapshot,
+    store.getSnapshot,
+  ) as T;
+};
+
+interface GlobalProviderProps {
+  global?: object;
+  children?: ReactNode;
+}
+
+export const GlobalProvider: React.FC<GlobalProviderProps> = ({
+  global,
+  children,
+}) => {
+  useEffect(() => {
+    if (global !== undefined) {
+      setGlobal(global);
+    }
+  }, [global]);
+
+  return (
+    <GlobalContext.Provider value={globalStore}>
+      {children}
+    </GlobalContext.Provider>
+  );
+};

package/src/Common/NetworkServiceCall.ts

@@ -1,299 +1,267 @@
-import axios, { Method, AxiosResponse, AxiosError } from 'axios';
-import { isConnected, notifyMessage, ValueCheck } from '../CommonStyle/ComponentFunctions';
-import { Global } from '../../../../../src/Common/Global';
-;
+import axios from 'axios';
+import { notifyMessage, ValueCheck } from '../CommonStyle/ComponentFunctions';
+import { Global } from '../.../../../../../../src/Common/Global';
 import { Platform } from 'react-native';
+import { networkServiceCall } from 'react-native-electron-platform';
 
-// Type definitions
-export type HttpMethod = 'get' | 'post' | 'multiform';
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
 
-export interface NetworkResponse {
-  data: any;
-  httpstatus: number;
+interface AlertData {
+  alertCaption: string;
+  alertMessage?: string;
+  alertContent?: string;
+  alertHttpstatus?: number;
 }
 
-export interface ErrorResponseData {
+interface ErrorData {
   title: string;
   subtitle: string;
-  alertdata: {
-    alertCaption: string;
-    alertMessage: string;
-    alertContent: string;
-    alertHttpstatus: number;
-  };
+  alertdata: AlertData;
 }
 
-export interface ErrorResponse {
+interface ServiceResponse<T = unknown> {
   httpstatus: number;
-  data: ErrorResponseData;
+  data: T | ErrorData;
 }
 
-// Type for electron API if available
-declare global {
-  interface Window {
-    electronAPI?: {
-      networkCall: (method: string, url: string, params?: any) => Promise<NetworkResponse>;
-    };
-  }
+interface RawHttpPayload {
+  httpstatus?: number;
+  data?: unknown;
+  message?: string;
+}
+
+interface ElectronResponse {
+  httpstatus: number;
+  data: unknown;
+  message?: string;
 }
 
-type NetworkServiceCallFunction = (
-  method: HttpMethod | string,
+type NetworkServiceMethod = 'get' | 'post' | 'multiform' | string;
+
+export type NetworkServiceCallFn = <T = unknown>(
+  method: NetworkServiceMethod,
   url: string,
-  params?: any,
+  params?: unknown,
   jwt?: string,
   timeout?: number
-) => Promise<NetworkResponse | ErrorResponse>;
+) => Promise<ServiceResponse<T>>;
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function makeErrorResponse(
+  httpstatus: number,
+  message?: string
+): ServiceResponse<never> {
+  return {
+    httpstatus,
+    data: {
+      title: 'ERROR',
+      subtitle: '',
+      alertdata: {
+        alertCaption: 'ERROR',
+        alertMessage: message,
+        alertContent: message,
+        alertHttpstatus: httpstatus,
+      },
+    },
+  };
+}
 
-const NetworkServiceCall: NetworkServiceCallFunction = (method, url, params, jwt, timeout) => {
-  let jwtString = ValueCheck(Global.JWTToken) ? Global.JWTToken : jwt;
-  let dataset: NetworkResponse | ErrorResponse = {};
+// ---------------------------------------------------------------------------
+// Service call
+// ---------------------------------------------------------------------------
 
-  if (method.toLowerCase() === 'get') {
+const NetworkServiceCall: NetworkServiceCallFn = (
+  method,
+  url,
+  params,
+  jwt,
+  timeout
+) => {
+  const jwtString = ValueCheck(Global.JWTToken) ? Global.JWTToken : jwt;
+  // jwtString unused at call sites right now — kept for parity with the
+  // original (Authorization header is commented out in every branch).
+  void jwtString;
+
+  console.log('----------------------------- BUTTONAPI -----------------', url);
+
+  const lowerMethod = method.toLowerCase();
+
+  // -----------------------------------------------------------------------
+  // GET
+  // -----------------------------------------------------------------------
+  if (lowerMethod === 'get') {
     return axios({
-      method: 'get' as Method,
-      url: url,
+      method: 'get',
+      url,
       timeout: timeout || 60000,
+      // ⚠️ Original used `validateStatus: false`, which makes EVERY response
+      // (including 200) reject into `.catch`. That likely broke every GET.
+      // Preserved for behavioral parity; change to `() => true` to actually
+      // accept 2xx responses via the `.then` path.
       validateStatus: false,
-      // headers: {
-      //   Authorization: `Bearer ${jwtString}`,
-      // }
     })
-      .then(function (response: AxiosResponse): NetworkResponse | ErrorResponse {
-        if (response.data.httpstatus === 200) {
-          dataset = {
-            data: response.data.data,
-            httpstatus: response.data.httpstatus,
-          };
-          return dataset as NetworkResponse;
-        } else {
-          dataset = {
-            httpstatus: response.data.httpstatus,
-            data: {
-              title: 'ERROR',
-              subtitle: response.data.data !== undefined ? response.data.data.message : '',
-              alertdata: {
-                alertCaption: 'ERROR',
-                alertMessage: response.data.message,
-                alertContent: response.data.message,
-                alertHttpstatus: response.data.httpstatus,
-              },
-            },
-          };
-          return dataset as ErrorResponse;
+      .then((response) => {
+        const payload = response.data as RawHttpPayload;
+        if (payload.httpstatus === 200) {
+          return { data: payload.data, httpstatus: payload.httpstatus };
         }
-      })
-      .catch(function (error: AxiosError): ErrorResponse {
-        dataset = {
-          httpstatus: 404,
+        return {
+          httpstatus: payload.httpstatus ?? 0,
           data: {
             title: 'ERROR',
-            subtitle: '',
+            subtitle:
+              payload.data != undefined
+                ? (payload.data as { message?: string }).message ?? ''
+                : '',
             alertdata: {
               alertCaption: 'ERROR',
-              alertMessage: error.message,
-              alertContent: error.message,
-              alertHttpstatus: 404,
+              alertMessage: payload.message,
+              alertContent: payload.message,
+              alertHttpstatus: payload.httpstatus,
             },
           },
         };
-        return dataset as ErrorResponse;
-      });
+      })
+      .catch((error: Error) => makeErrorResponse(404, error.message)) as Promise<
+      ServiceResponse
+    >;
   }
-  else if (method.toLowerCase() === 'post' && Platform.OS !== 'web') {
-    return axios.post(url, params, {
-      // headers: {
-      //   Authorization: `Bearer ${jwtString}`,
-      // }
-    })
-      .then(function (response: AxiosResponse): NetworkResponse | ErrorResponse {
-        if (response.data.httpstatus === 200) {
-          dataset = {
-            data: response.data.data,
-            httpstatus: response.data.httpstatus,
-          };
-          return dataset as NetworkResponse;
-        } else {
-          dataset = {
-            httpstatus: response.data.httpstatus,
-            data: {
-              title: 'ERROR',
-              subtitle: '',
-              alertdata: {
-                alertCaption: 'ERROR',
-                alertMessage: response.data.message,
-                alertContent: response.data.message,
-                alertHttpstatus: response.data.httpstatus,
-              },
-            },
-          };
-          return dataset as ErrorResponse;
+
+  // -----------------------------------------------------------------------
+  // POST — native
+  // -----------------------------------------------------------------------
+  if (lowerMethod === 'post' && Platform.OS !== 'web') {
+    return axios
+      .post(url, params)
+      .then((response) => {
+        const payload = response.data as RawHttpPayload;
+        if (payload.httpstatus === 200) {
+          return { data: payload.data, httpstatus: payload.httpstatus };
         }
-      })
-      .catch(function (error: AxiosError): ErrorResponse {
-        dataset = {
-          httpstatus: 404,
+        return {
+          httpstatus: payload.httpstatus ?? 0,
           data: {
             title: 'ERROR',
             subtitle: '',
             alertdata: {
               alertCaption: 'ERROR',
-              alertMessage: error.message,
-              alertContent: error.message,
-              alertHttpstatus: 404,
+              alertMessage: payload.message,
+              alertContent: payload.message,
+              alertHttpstatus: payload.httpstatus,
             },
           },
         };
-        return dataset as ErrorResponse;
-      });
+      })
+      .catch((error: Error) => makeErrorResponse(404, error.message)) as Promise<
+      ServiceResponse
+    >;
   }
-  else if (method.toLowerCase() === 'multiform' && Platform.OS !== 'web') {
+
+  // -----------------------------------------------------------------------
+  // MULTIFORM — native
+  // -----------------------------------------------------------------------
+  if (lowerMethod === 'multiform' && Platform.OS !== 'web') {
     console.log('JWT STRING', jwtString);
 
     return axios({
-      url: url,
+      url,
       method: 'POST',
       headers: {
         'Content-Type': 'multipart/form-data',
-        // Authorization: `Bearer ${jwtString}`,
       },
       data: params,
     })
-      .then(function (response: AxiosResponse): NetworkResponse | ErrorResponse {
+      .then((response) => {
         if (response.status === 200) {
-          dataset = {
-            data: response.data,
-            httpstatus: response.status,
-          };
-          return dataset as NetworkResponse;
-        } else {
-          dataset = {
-            httpstatus: response.status,
-            data: {
-              title: 'ERROR',
-              subtitle: '',
-              alertdata: {
-                alertCaption: 'ERROR',
-                alertMessage: response.data.message,
-                alertContent: response.data.message,
-                alertHttpstatus: response.data.httpstatus,
-              },
-            },
-          };
-          return dataset as ErrorResponse;
+          return { data: response.data, httpstatus: response.status };
         }
-      })
-      .catch((error: AxiosError): ErrorResponse => {
-        dataset = {
-          httpstatus: 404,
+        const payload = response.data as RawHttpPayload;
+        return {
+          httpstatus: response.status,
           data: {
             title: 'ERROR',
             subtitle: '',
             alertdata: {
               alertCaption: 'ERROR',
-              alertMessage: error.message,
-              alertContent: error.message,
-              alertHttpstatus: 404,
+              alertMessage: payload.message,
+              alertContent: payload.message,
+              alertHttpstatus: payload.httpstatus,
             },
           },
         };
-        return dataset as ErrorResponse;
-      });
+      })
+      .catch((error: Error) => makeErrorResponse(404, error.message)) as Promise<
+      ServiceResponse
+    >;
   }
-  else if (method.toLowerCase() === 'post' && Platform.OS === 'web') {
-    // Check if electronAPI is available
-    if (typeof window !== 'undefined' && window.electronAPI) {
-      return window.electronAPI.networkCall('post', url, params)
-        .then(function (response: NetworkResponse): NetworkResponse | ErrorResponse {
-          if (response.httpstatus === 200) {
-            dataset = {
-              data: response.data,
-              httpstatus: response.httpstatus,
-            };
-            return dataset as NetworkResponse;
-          } else {
-            dataset = {
-              httpstatus: response.httpstatus,
-              data: {
-                title: 'ERROR',
-                subtitle: '',
-                alertdata: {
-                  alertCaption: 'ERROR',
-                  alertMessage: (response as any).message || '',
-                  alertContent: (response as any).message || '',
-                  alertHttpstatus: response.httpstatus,
-                },
-              },
-            };
-            return dataset as ErrorResponse;
-          }
-        })
-        .catch(function (error: Error): ErrorResponse {
-          dataset = {
-            httpstatus: 404,
-            data: {
-              title: 'ERROR',
-              subtitle: '',
-              alertdata: {
-                alertCaption: 'ERROR',
-                alertMessage: error.message,
-                alertContent: error.message,
-                alertHttpstatus: 404,
-              },
+
+  // -----------------------------------------------------------------------
+  // POST — web (electron)
+  // -----------------------------------------------------------------------
+  if (lowerMethod === 'post' && Platform.OS === 'web') {
+    return networkServiceCall('post', url, params)
+      .then((response: ElectronResponse) => {
+        if (response.httpstatus === 200) {
+          return { data: response.data, httpstatus: response.httpstatus };
+        }
+        return {
+          httpstatus: response.httpstatus,
+          data: {
+            title: 'ERROR',
+            subtitle: '',
+            alertdata: {
+              alertCaption: 'ERROR',
+              alertMessage: response.message,
+              alertContent: response.message,
+              alertHttpstatus: response.httpstatus,
             },
-          };
-          return dataset as ErrorResponse;
-        });
-    } else {
-      // Fallback to regular axios if electronAPI is not available
-      return axios.post(url, params, {
-        timeout: timeout || 60000,
+          },
+        };
       })
-        .then(function (response: AxiosResponse): NetworkResponse | ErrorResponse {
-          if (response.status === 200) {
-            dataset = {
-              data: response.data,
-              httpstatus: response.status,
-            };
-            return dataset as NetworkResponse;
-          } else {
-            dataset = {
-              httpstatus: response.status,
-              data: {
-                title: 'ERROR',
-                subtitle: '',
-                alertdata: {
-                  alertCaption: 'ERROR',
-                  alertMessage: response.data?.message || 'Request failed',
-                  alertContent: response.data?.message || 'Request failed',
-                  alertHttpstatus: response.status,
-                },
-              },
-            };
-            return dataset as ErrorResponse;
-          }
-        })
-        .catch(function (error: AxiosError): ErrorResponse {
-          dataset = {
-            httpstatus: 404,
-            data: {
-              title: 'ERROR',
-              subtitle: '',
-              alertdata: {
-                alertCaption: 'ERROR',
-                alertMessage: error.message,
-                alertContent: error.message,
-                alertHttpstatus: 404,
-              },
+      .catch((error: Error) => makeErrorResponse(404, error.message)) as Promise<
+      ServiceResponse
+    >;
+  }
+
+  // -----------------------------------------------------------------------
+  // MULTIFORM — web (electron)
+  // -----------------------------------------------------------------------
+  if (lowerMethod === 'multiform' && Platform.OS === 'web') {
+    const headers = {
+      'Content-Type': 'multipart/form-data',
+    };
+    return networkServiceCall('post', url, params, headers)
+      .then((response: ElectronResponse) => {
+        if (response.httpstatus === 200) {
+          return { data: response.data, httpstatus: response.httpstatus };
+        }
+        return {
+          httpstatus: response.httpstatus,
+          data: {
+            title: 'ERROR',
+            subtitle: '',
+            alertdata: {
+              alertCaption: 'ERROR',
+              alertMessage: response.message,
+              alertContent: response.message,
+              alertHttpstatus: response.httpstatus,
             },
-          };
-          return dataset as ErrorResponse;
-        });
-    }
+          },
+        };
+      })
+      .catch((error: Error) => makeErrorResponse(404, error.message)) as Promise<
+      ServiceResponse
+    >;
   }
 
-  // Default return for unmatched conditions
-  return Promise.reject(new Error('Invalid method or platform combination'));
+  // Unknown method — original fell through and returned `undefined`
+  console.warn(`NetworkServiceCall: unsupported method "${method}"`);
+  return Promise.resolve(makeErrorResponse(400, `Unsupported method: ${method}`));
 };
 
 export default NetworkServiceCall;

package/src/Components/SDropDown.tsx

@@ -14,7 +14,7 @@ import {
   ViewStyle,
   TextStyle,
 } from 'react-native';
-import { APIURL } from '../../../../../src/Common/apiConstants';
+import { APIURL } from '@jescon-technologies/react-native-ui-kit';
 import Loader from '../Custom/Loader';
 import { isBNU, isBNUL, isNU, normalize } from '../CommonStyle/ComponentFunctions';
 import NetworkServiceCall from '../Common/NetworkServiceCall';

package/src/Custom/CSliderMenu.tsx

@@ -11,7 +11,7 @@ import {
 import { normalize} from '../CommonStyle/ComponentFunctions';
 import RNExitApp from 'react-native-exit-app';
 import { Global, GlobalUserData } from '../../../../../src/Common/Global';
-import { imageURL } from '../../../../../src/Common/apiConstants';
+import { imageURL } from '@jescon-technologies/react-native-ui-kit';
 import { useNavigation } from '../Navigation/useNavigation';
 import CModalOverlay from '../CustomComponents/CModalOverlay';
 import HIcons from '../Hoc/HIcons';

package/src/Custom/Loader.tsx

@@ -13,7 +13,7 @@ import {
   TextStyle,
 } from 'react-native';
 import { normalize} from '../CommonStyle/ComponentFunctions';
-import { APIURL } from '../../../../../src/Common/apiConstants';
+import { imageURL } from '@jescon-technologies/react-native-ui-kit';
 
 // ---------------------------------------------------------------------------
 // Types
@@ -45,7 +45,7 @@ export default function Loader({
   overlayColor = 'rgba(0,0,0,0.4)',
   loaderColor = 'lightblue',
   size = Platform.OS !== 'web' ? 30 : 50,
-  gifSource = { uri: `${APIURL}file/getCommonFile/image/heartpulse.gif` },
+  gifSource = { uri: `${imageURL}heartpulse.gif` },
   message = '',
   messageStyle = {},
   animationType = 'fade',

package/src/CustomComponents/HeaderBlock.tsx

@@ -33,7 +33,7 @@ import NetworkServiceCall from '../Common/NetworkServiceCall';
 import HIcons from '../Hoc/HIcons';
 import ResponseComponentContext from '../Handlers/ResponseComponentContext';
 import { Global } from '../../../../../src/Common/Global';
-import { APIURL } from '../../../../../src/Common/apiConstants';
+import { notifyURL } from '../../../../../src/Common/apiConstants';
 
 // import HelpdeskScreenFocus from '../Helpdesk/View/HelpdeskScreenFocus';
 // import CHelpdeskView from '../Helpdesk/View/CHelpdeskView';
@@ -50,7 +50,6 @@ interface HeaderBlockProps {
   webview?: unknown;
   data?: unknown;
   navigation?: (route: string, params?: object) => void;
-  APIURL?: string;
   [key: string]: unknown;
 }
 
@@ -358,9 +357,7 @@ const HeaderBlock: React.FC<HeaderBlockProps> = (props) => {
     const userData = Global.userData as UserDataLite | null | undefined;
     if (userData && userData.suuser) {
       setIsLoadingNotifications(true);
-      const url =
-        APIURL + 'invget/invcommonget/rnhrsumessageuserretrievaljson ' + userData.suuser;
-      NetworkServiceCall('get', url)
+      NetworkServiceCall('get',`${notifyURL} ${userData.suuser}`)
         .then((response: NetworkResponse<NotificationItem[] | NotificationsPayload>) => {
           setIsLoadingNotifications(false);
           if (response && response.httpstatus == 200) {

package/src/Hoc/HDashboard.tsx

@@ -32,7 +32,6 @@ import HShadowButton from './HShadowButton';
 import HIcons from './HIcons';
 import { normalize} from '../CommonStyle/ComponentFunctions';
 import { Global } from '../../../../../src/Common/Global';
-;
 import SDateTimePicker from '../StaticComponents/SDateTimePicker';
 
 // ---------------------------------------------------------------------------

package/src/Hoc/HProvider.tsx

@@ -2,20 +2,27 @@ import React from 'react';
 import HView from '../Hoc/HView';
 import Navigation from '../Navigation/PageNavigation';
 import ErrorBoundary from '../Common/ErrorBoundary';
+import { GlobalProvider } from '../Common/GlobalContext';
 import { SafeAreaView } from 'react-native-safe-area-context';
 
 interface HProviderProps {
     components: Record<string, React.ComponentType<any>>;
     screens: any;
+    Global?: object;
+    global?: object;
 }
 export default function HProvider(props: HProviderProps) {
+    const global = props.Global ?? props.global;
+
     return (
-        <SafeAreaView style={{ flex: 1 }}>
-            <ErrorBoundary>
-                <HView components={props.components}>
-                    <Navigation screens={props.screens} />
-                </HView>
-            </ErrorBoundary>
-        </SafeAreaView>
+        <GlobalProvider global={global}>
+            <SafeAreaView style={{ flex: 1 }}>
+                <ErrorBoundary>
+                    <HView components={props.components}>
+                        <Navigation screens={props.screens} />
+                    </HView>
+                </ErrorBoundary>
+            </SafeAreaView>
+        </GlobalProvider>
     );
 }