@jescon-technologies/react-native-ui-kit 0.0.10 → 0.0.12

package/index.d.ts

@@ -1,3 +1,11 @@
 export { default as ErrorBoundary } from './src/Common/ErrorBoundary';
-export { default as AAlertIOS } from './Alerts/AAlertIOS';
-export { default as AAlert } from './Alerts/AAlert';
+export { default as AAlertIOS } from './src/Alerts/AAlertIOS';
+export { default as AAlert } from './src/Alerts/AAlert';
+export { default as ABlink } from './src/Alerts/ABlink';
+export { default as HIcons } from './src/Hoc/HIcons';
+export { default as NetworkServiceCall } from './src/Common/NetworkServiceCall';
+export * from './src/Navigation/useNavigation';
+export { default as CBackHandler } from './src/CustomComponents/CBackHandler';
+export * from './src/CommonStyle/ComponentFunctions';
+export * from './src/CommonStyle/commonStyle';
+export { default as Loader } from './src/Custom/Loader';

package/index.js

@@ -1,3 +1,11 @@
 export { default as ErrorBoundary } from './src/Common/ErrorBoundary';
 export { default as AAlertIOS } from './src/Alerts/AAlertIOS';
-export { default as AAlert } from './src/Alerts/AAlert';
+export { default as AAlert } from './src/Alerts/AAlert';
+export { default as ABlink } from './src/Alerts/ABlink';
+export { default as HIcons } from './src/Hoc/HIcons';
+export { default as NetworkServiceCall } from './src/Common/NetworkServiceCall';
+export * from './src/Navigation/useNavigation';
+export { default as CBackHandler } from './src/CustomComponents/CBackHandler';
+export * from './src/CommonStyle/ComponentFunctions';
+export * from './src/CommonStyle/commonStyle';
+export { default as Loader } from './src/Custom/Loader';

package/package.json

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

package/src/Alerts/AAlert.tsx

@@ -9,7 +9,7 @@ import {
 } from 'react-native';
 
 import { Global } from '../../../../../src/Common/Global';
-import Icons from '../Common/Icons';
+import HIcons from '../Hoc/HIcons';
 import { ValueCheck } from '../CommonStyle/ComponentFunctions';
 import { normalize } from '../CommonStyle/componentStyle';
 import CModalOverlay from '../CustomComponents/CModalOverlay';
@@ -120,7 +120,7 @@ const AAlert: React.FC<Props> = (props) => {
         }}
         onPress={handleClose}
       >
-        <Icons.AntDesign
+        <HIcons.AntDesign
           name="closecircleo"
           size={normalize(15)}
           color="#fff"
@@ -147,7 +147,7 @@ const AAlert: React.FC<Props> = (props) => {
             source={require('../../../../../android/app/src/main/res/mipmap-xxxhdpi/ic_launcher_round.png')}
           />
 
-          <Icons.Entypo
+          <HIcons.Entypo
             color="#fff"
             name="info"
             size={normalize(15)}

package/src/Alerts/AAlertIOS.tsx

@@ -8,7 +8,7 @@ import {
 } from 'react-native';
 
 import { Global } from '../../../../../src/Common/Global';
-import Icons from '../Common/Icons';
+import HIcons from '../Hoc/HIcons';
 import { ValueCheck } from '../CommonStyle/ComponentFunctions';
 import { normalize } from '../CommonStyle/componentStyle';
 
@@ -108,7 +108,7 @@ const AAlertIOS: React.FC<Props> = (props) => {
             flex: 1,
           }}
         >
-          <Icons.Entypo
+          <HIcons.Entypo
             color="#fff"
             name="info"
             size={normalize(15)}

package/src/Alerts/ABlink.tsx

@@ -0,0 +1,56 @@
+import React, { Component } from 'react';
+import { Animated, View, ViewStyle, StyleProp } from 'react-native';
+
+interface ABlinkProps {
+  duration?: number;
+  repeat_count?: number;
+  style?: StyleProp<ViewStyle>;
+  children?: React.ReactNode;
+}
+
+interface ABlinkState {
+  // No state needed, but keeping for consistency
+}
+
+export default class ABlink extends Component<ABlinkProps, ABlinkState> {
+  private fadeAnimation: Animated.Value;
+
+  constructor(props: ABlinkProps) {
+    super(props);
+    this.fadeAnimation = new Animated.Value(0);
+  }
+
+  componentDidMount(): void {
+    const { duration = 1000, repeat_count = -1 } = this.props;
+    
+    Animated.loop(
+      Animated.sequence([
+        Animated.timing(this.fadeAnimation, {
+          toValue: 0,
+          duration: duration,
+          useNativeDriver: true,
+        }),
+        Animated.timing(this.fadeAnimation, {
+          toValue: 1,
+          duration: duration,
+          useNativeDriver: true,
+        }),
+      ]),
+      {
+        iterations: repeat_count,
+      }
+    ).start();
+  }
+
+  render(): React.JSX.Element {
+    const { style, children } = this.props;
+    
+    return (
+      <View style={style}>
+        <Animated.View style={{ opacity: this.fadeAnimation }}>
+          {children}
+        </Animated.View>
+      </View>
+    );
+  }
+}

package/src/Common/NetworkServiceCall.ts

@@ -0,0 +1,298 @@
+import axios, { Method, AxiosResponse, AxiosError } from 'axios';
+import { isConnected, notifyMessage, ValueCheck } from '../CommonStyle/ComponentFunctions';
+import { Global } from '../../../../../src/Common/Global';
+import { Platform } from 'react-native';
+
+// Type definitions
+export type HttpMethod = 'get' | 'post' | 'multiform';
+
+export interface NetworkResponse {
+  data: any;
+  httpstatus: number;
+}
+
+export interface ErrorResponseData {
+  title: string;
+  subtitle: string;
+  alertdata: {
+    alertCaption: string;
+    alertMessage: string;
+    alertContent: string;
+    alertHttpstatus: number;
+  };
+}
+
+export interface ErrorResponse {
+  httpstatus: number;
+  data: ErrorResponseData;
+}
+
+// Type for electron API if available
+declare global {
+  interface Window {
+    electronAPI?: {
+      networkCall: (method: string, url: string, params?: any) => Promise<NetworkResponse>;
+    };
+  }
+}
+
+type NetworkServiceCallFunction = (
+  method: HttpMethod | string,
+  url: string,
+  params?: any,
+  jwt?: string,
+  timeout?: number
+) => Promise<NetworkResponse | ErrorResponse>;
+
+const NetworkServiceCall: NetworkServiceCallFunction = (method, url, params, jwt, timeout) => {
+  let jwtString = ValueCheck(Global.JWTToken) ? Global.JWTToken : jwt;
+  let dataset: NetworkResponse | ErrorResponse = {};
+
+  if (method.toLowerCase() === 'get') {
+    return axios({
+      method: 'get' as Method,
+      url: url,
+      timeout: timeout || 60000,
+      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;
+        }
+      })
+      .catch(function (error: AxiosError): ErrorResponse {
+        dataset = {
+          httpstatus: 404,
+          data: {
+            title: 'ERROR',
+            subtitle: '',
+            alertdata: {
+              alertCaption: 'ERROR',
+              alertMessage: error.message,
+              alertContent: error.message,
+              alertHttpstatus: 404,
+            },
+          },
+        };
+        return dataset as ErrorResponse;
+      });
+  }
+  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;
+        }
+      })
+      .catch(function (error: AxiosError): ErrorResponse {
+        dataset = {
+          httpstatus: 404,
+          data: {
+            title: 'ERROR',
+            subtitle: '',
+            alertdata: {
+              alertCaption: 'ERROR',
+              alertMessage: error.message,
+              alertContent: error.message,
+              alertHttpstatus: 404,
+            },
+          },
+        };
+        return dataset as ErrorResponse;
+      });
+  }
+  else if (method.toLowerCase() === 'multiform' && Platform.OS !== 'web') {
+    console.log('JWT STRING', jwtString);
+
+    return axios({
+      url: url,
+      method: 'POST',
+      headers: {
+        'Content-Type': 'multipart/form-data',
+        // Authorization: `Bearer ${jwtString}`,
+      },
+      data: params,
+    })
+      .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,
+                alertContent: response.data.message,
+                alertHttpstatus: response.data.httpstatus,
+              },
+            },
+          };
+          return dataset as ErrorResponse;
+        }
+      })
+      .catch((error: AxiosError): ErrorResponse => {
+        dataset = {
+          httpstatus: 404,
+          data: {
+            title: 'ERROR',
+            subtitle: '',
+            alertdata: {
+              alertCaption: 'ERROR',
+              alertMessage: error.message,
+              alertContent: error.message,
+              alertHttpstatus: 404,
+            },
+          },
+        };
+        return dataset as ErrorResponse;
+      });
+  }
+  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,
+              },
+            },
+          };
+          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,
+              },
+            },
+          };
+          return dataset as ErrorResponse;
+        });
+    }
+  }
+
+  // Default return for unmatched conditions
+  return Promise.reject(new Error('Invalid method or platform combination'));
+};
+
+export default NetworkServiceCall;