react-native-altibbi 0.1.3 → 0.1.4

package/lib/src/scoket.js

@@ -0,0 +1,232 @@
+import { NativeModules, NativeEventEmitter, Platform } from 'react-native';
+const LINKING_ERROR = `The package 'react-native-altibbi' doesn't seem to be linked. Make sure: \n\n` +
+    Platform.select({ ios: "- You have run 'pod install'\n", default: '' }) +
+    '- You rebuilt the app after installing the package\n' +
+    '- You are not using Expo managed workflow\n';
+const SocketReactNative = NativeModules.SocketReactNative
+    ? NativeModules.SocketReactNative
+    : new Proxy({}, {
+        get() {
+            throw new Error(LINKING_ERROR);
+        },
+    });
+var SocketEventName;
+(function (SocketEventName) {
+    SocketEventName["ON_AUTHORIZER"] = "SocketReactNative:onAuthorizer";
+    SocketEventName["ON_CONNECTION_STATE_CHANGE"] = "SocketReactNative:onConnectionStateChange";
+    SocketEventName["ON_SUBSCRIPTION_ERROR"] = "SocketReactNative:onSubscriptionError";
+    SocketEventName["ON_EVENT"] = "SocketReactNative:onEvent";
+    SocketEventName["ON_ERROR"] = "SocketReactNative:onError";
+    SocketEventName["ON_MEMBER_ADDED"] = "SocketReactNative:onMemberAdded";
+    SocketEventName["ON_MEMBER_REMOVED"] = "SocketReactNative:onMemberRemoved";
+})(SocketEventName || (SocketEventName = {}));
+export class TBISocketEvent {
+    channelName;
+    eventName;
+    data;
+    userId;
+    constructor(args) {
+        this.channelName = args.channelName;
+        this.eventName = args.eventName;
+        this.data = args.data;
+        this.userId = args.userId;
+    }
+    toString() {
+        return `{ channelName: ${this.channelName}, eventName: ${this.eventName}, data: ${this.data}, userId: ${this.userId} }`;
+    }
+}
+export class TBISocketMember {
+    userId;
+    userInfo;
+    constructor(userId, userInfo) {
+        this.userId = userId;
+        this.userInfo = userInfo;
+    }
+    toString() {
+        return `{ userId: ${this.userId}, userInfo: ${JSON.stringify(this.userInfo)} }`;
+    }
+}
+export class TBISocketChannel {
+    channelName;
+    members = new Map();
+    me;
+    subscriptionCount;
+    onSubscriptionSucceeded;
+    onSubscriptionCount;
+    onEvent;
+    onMemberAdded;
+    onMemberRemoved;
+    constructor(args) {
+        this.channelName = args.channelName;
+        this.onSubscriptionSucceeded = args.onSubscriptionSucceeded;
+        this.onEvent = args.onEvent;
+        this.onMemberAdded = args.onMemberAdded;
+        this.onMemberRemoved = args.onMemberRemoved;
+        this.onSubscriptionCount = args.onSubscriptionCount;
+        this.me = args.me;
+    }
+    async unsubscribe() {
+        return TBISocket.getInstance().unsubscribe({
+            channelName: this.channelName,
+        });
+    }
+    async trigger(event) {
+        if (event.channelName !== this.channelName) {
+            throw 'Event is not for this channel';
+        }
+        return TBISocket.getInstance().trigger(event);
+    }
+}
+export class TBISocket {
+    static instance;
+    socketEventEmitter = new NativeEventEmitter(SocketReactNative);
+    channels = new Map();
+    connectionState = 'DISCONNECTED';
+    constructor() { }
+    static getInstance() {
+        if (!TBISocket.instance) {
+            TBISocket.instance = new TBISocket();
+        }
+        return TBISocket.instance;
+    }
+    addListener(socketEventName, callback) {
+        return this.socketEventEmitter.addListener(socketEventName, callback);
+    }
+    init(args) {
+        this.removeAllListeners();
+        this.addListener(SocketEventName.ON_CONNECTION_STATE_CHANGE, (event) => {
+            this.connectionState = event.currentState.toUpperCase();
+            args.onConnectionStateChange?.(event.currentState.toUpperCase(), event.previousState.toUpperCase());
+        });
+        this.addListener(SocketEventName.ON_ERROR, (event) => args.onError?.(event.message, event.code, event.error));
+        this.addListener(SocketEventName.ON_EVENT, (event) => {
+            const channelName = event.channelName;
+            const eventName = event.eventName;
+            const data = event.data;
+            const userId = event.userId;
+            const channel = this.channels.get(channelName);
+            switch (eventName) {
+                case 'socket_internal:subscription_succeeded':
+                    // Depending on the platform implementation we get json or a Map.
+                    var decodedData = data instanceof Object ? data : JSON.parse(data);
+                    for (const _userId in decodedData?.presence?.hash) {
+                        const userInfo = decodedData?.presence?.hash[_userId];
+                        var member = new TBISocketMember(_userId, userInfo);
+                        channel?.members.set(member.userId, member);
+                        if (_userId === userId && channel) {
+                            channel.me = member;
+                        }
+                    }
+                    args.onSubscriptionSucceeded?.(channelName, decodedData);
+                    channel?.onSubscriptionSucceeded?.(decodedData);
+                    break;
+                case 'socket_internal:subscription_count':
+                    // Depending on the platform implementation we get json or a Map.
+                    var decodedData = data instanceof Object ? data : JSON.parse(data);
+                    if (channel) {
+                        channel.subscriptionCount = decodedData.subscription_count;
+                    }
+                    args.onSubscriptionCount?.(channelName, decodedData.subscription_count);
+                    channel?.onSubscriptionCount?.(decodedData.subscription_count);
+                    break;
+                default:
+                    const socketEvent = new TBISocketEvent(event);
+                    args.onEvent?.(socketEvent);
+                    channel?.onEvent?.(socketEvent);
+                    break;
+            }
+        });
+        this.addListener(SocketEventName.ON_MEMBER_ADDED, (event) => {
+            const user = event.user;
+            const channelName = event.channelName;
+            var member = new TBISocketMember(user.userId, user.userInfo);
+            const channel = this.channels.get(channelName);
+            channel?.members.set(member.userId, member);
+            args.onMemberAdded?.(channelName, member);
+            channel?.onMemberAdded?.(member);
+        });
+        this.addListener(SocketEventName.ON_MEMBER_REMOVED, (event) => {
+            const user = event.user;
+            const channelName = event.channelName;
+            var member = new TBISocketMember(user.userId, user.userInfo);
+            const channel = this.channels.get(channelName);
+            channel?.members.delete(member.userId);
+            args.onMemberRemoved?.(channelName, member);
+            channel?.onMemberRemoved?.(member);
+        });
+        this.addListener(SocketEventName.ON_AUTHORIZER, async ({ channelName, socketId }) => {
+            const data = await args.onAuthorizer?.(channelName, socketId);
+            if (data) {
+                await SocketReactNative.onAuthorizer(channelName, socketId, data);
+            }
+        });
+        this.addListener(SocketEventName.ON_SUBSCRIPTION_ERROR, async ({ channelName, message, type }) => {
+            args.onSubscriptionError?.(channelName, message, type);
+        });
+        return SocketReactNative.initialize({
+            apiKey: args.apiKey,
+            cluster: args.cluster,
+            authEndpoint: args.authEndpoint,
+            useTLS: args.useTLS,
+            activityTimeout: args.activityTimeout,
+            pongTimeout: args.pongTimeout,
+            maxReconnectionAttempts: args.maxReconnectionAttempts,
+            maxReconnectGapInSeconds: args.maxReconnectGapInSeconds,
+            authorizerTimeoutInSeconds: args.authorizerTimeoutInSeconds,
+            authorizer: args.onAuthorizer ? true : false,
+            proxy: args.proxy,
+        });
+    }
+    async connect() {
+        return await SocketReactNative.connect();
+    }
+    async disconnect() {
+        return await SocketReactNative.disconnect();
+    }
+    unsubscribeAllChannels() {
+        const channelsCopy = new Map(this.channels);
+        channelsCopy.forEach((channel) => {
+            this.unsubscribe({ channelName: channel.channelName });
+        });
+    }
+    removeAllListeners() {
+        this.socketEventEmitter.removeAllListeners(SocketEventName.ON_AUTHORIZER);
+        this.socketEventEmitter.removeAllListeners(SocketEventName.ON_ERROR);
+        this.socketEventEmitter.removeAllListeners(SocketEventName.ON_EVENT);
+        this.socketEventEmitter.removeAllListeners(SocketEventName.ON_MEMBER_ADDED);
+        this.socketEventEmitter.removeAllListeners(SocketEventName.ON_MEMBER_REMOVED);
+    }
+    async reset() {
+        this.removeAllListeners();
+        this.unsubscribeAllChannels();
+    }
+    async subscribe(args) {
+        const channel = this.channels.get(args.channelName);
+        if (channel) {
+            return channel;
+        }
+        const newChannel = new TBISocketChannel(args);
+        await SocketReactNative.subscribe(args.channelName);
+        this.channels.set(args.channelName, newChannel);
+        return newChannel;
+    }
+    async unsubscribe({ channelName }) {
+        await SocketReactNative.unsubscribe(channelName);
+        this.channels.delete(channelName);
+    }
+    async trigger(event) {
+        if (event.channelName.startsWith('private-') ||
+            event.channelName.startsWith('presence-')) {
+            await SocketReactNative.trigger(event.channelName, event.eventName, event.data);
+        }
+        else {
+            throw 'Trigger event is only for private/presence channels';
+        }
+    }
+    async getSocketId() {
+        return await SocketReactNative.getSocketId();
+    }
+    getChannel(channelName) {
+        return this.channels.get(channelName);
+    }
+}

package/lib/src/service.js

@@ -0,0 +1,12 @@
+export let TBIConstants = {
+    token: '',
+    baseURL: '',
+    language: 'ar',
+};
+export const init = (token, baseURL, language) => {
+    TBIConstants = {
+        token,
+        baseURL,
+        language,
+    };
+};

package/lib/src/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "react-native-altibbi",
-  "version": "0.1.3",
-  "description": "Altibbi Sdk",
+  "version": "0.1.4",
+  "description": "React native SDK provides integration for the Altibbi services, including video consultation, text consultation, push Welcome to the React Native SDK for Altibbi services, your comprehensive solution for integrating health consultation services into your React Native applications. This SDK enables video and text consultations, push notifications, and many other features to provide a seamless healthcare experience. project.",
   "main": "lib/commonjs/index",
   "module": "lib/module/index",
   "types": "@types/index.d.ts",
@@ -30,20 +30,22 @@
     "test": "jest",
     "typecheck": "tsc --noEmit",
     "lint": "eslint \"**/*.{js,ts,tsx}\"",
-    "clean": "del-cli android/build example/android/build example/android/app/build example/ios/build lib"
+    "clean": "del-cli android/build example/android/build example/android/app/build example/ios/build lib",
+    "build": "tsc"
   },
   "keywords": [
     "react-native",
     "ios",
-    "android"
+    "android",
+    "altibbi"
   ],
-  "repository": "https://github.com/altibbi-com/altibb-react-native",
-  "author": "Altibbi Tech team <mobile@altibbi.com> (https://github.com/altibbi-com/altibb-react-native)",
+  "repository": "https://github.com/altibbi-com/altibbi-react-native",
+  "author": "Altibbi Tech team <mobile@altibbi.com> (https://github.com/altibbi-com/altibbi-react-native)",
   "license": "MIT",
   "bugs": {
-    "url": "https://github.com/altibbi-com/altibb-react-native/issues"
+    "url": "https://github.com/altibbi-com/altibbi-react-native/issues"
   },
-  "homepage": "https://github.com/altibbi-com/altibb-react-native/readme",
+  "homepage": "https://github.com/altibbi-com/altibbi-react-native/readme",
   "publishConfig": {
     "registry": "https://registry.npmjs.org/"
   },
@@ -76,7 +78,7 @@
     "react-test-renderer": "18.2.0",
     "release-it": "^15.0.0",
     "turbo": "^1.10.7",
-    "typescript": "^5.0.2"
+    "typescript": "^5.3.3"
   },
   "resolutions": {
     "@types/react": "17.0.21"

package/react-native-altibbi.podspec

@@ -16,7 +16,6 @@ Pod::Spec.new do |s|
   s.source       = { :git => "https://bitbucket.org/altibbi/react-native-altibbi-sdk/src/master/.git", :tag => "#{s.version}" }
   s.dependency 'React'
   s.dependency 'PusherSwift', '~> 10.1.1'
-  #s.dependency 'OpenTok','~> 2.21.3'
   s.dependency 'OTXCFramework','2.26.1'
 
   s.source_files = "ios/**/*.{h,m,mm,swift}"

package/src/data.ts

@@ -1,4 +1,4 @@
-import {
+import type {
   BloodType,
   BoolString,
   GenderType,