@jibb-open/jssdk 3.5.8 → 3.5.10

package/src/ws/meeting.js

@@ -1,170 +0,0 @@
-import {Auth} from '../api/auth.js';
-import {Config} from "../config.js";
-import {logger} from "../utils/logger/index.js"
-import {RetryConnection} from "./retry_connection.js";
-import {ConnectionStatus} from "./connection_base.js";
-import {MeetingClaims} from "../types/types.js";
-
-import {meeting, types} from "../types/proto.js"
-let Message = meeting.Message
-let ErrorCode = types.Code
-
-if (globalThis?.WebSocket == undefined) {
-	import("isomorphic-ws").then((webSocket) => {
-		globalThis.WebSocket = webSocket.default;
-	});
-}
-
-class MeetingConnectionImp extends RetryConnection {
-	#expiryTimer
-	constructor() {
-		super('meeting')
-		this.meetingId = null
-		this.meetingToken = null
-		this.#expiryTimer = null
-	}
-
-	getName() {
-		return `${super.getName()}-${this.meetingId}`
-	}
-
-	async start(meetingToken) {
-		this.meetingToken = meetingToken
-		this.meetingClaims = new MeetingClaims(meetingToken)
-		this.meetingId = this.meetingClaims.meetindId
-		let seconds = this.meetingClaims.getSecondsUntilExpiry()
-		if (seconds <= 0) {
-			this.onErrorMessage(ErrorCode.ERR_TIMEOUT, "meeting token expired");
-			return
-		}
-		this.#expiryTimer = setTimeout(() => {
-			this.stop()
-			this.onErrorMessage(ErrorCode.ERR_TIMEOUT, "meeting token expired");
-		}, seconds)
-		super.start()
-	}
-
-	async stop() {
-		clearTimeout(this.#expiryTimer)
-		super.stop()
-	}
-
-	disconnect() {
-		if (this.socket != null) {
-			this.socket.close();
-			this.socket = null;
-			//	this.fireOnError(ErrorLevel.ERROR, ErrorCode.ERR_CLOSED, "closed") //this one fired after diconnection error causes multiple connection (it call retray connection again)
-			logger.info("meeting disconnect ", this.meetingId);
-		}
-
-		super.disconnect()
-	}
-
-	async connect() {
-		if (this.getConnectionStatus() != ConnectionStatus.DISCONNECTED)
-			return
-
-		super.connect()
-		let self = this;
-
-		try {
-			if (this.meetingClaims.isExpired()) {
-				self.onErrorMessage(ErrorCode.ERR_TIMEOUT, "meeting token expired");
-				return;
-			}
-		} catch (e) {
-			self.onErrorMessage(ErrorCode.ERR_BAD_REQUEST, "invalid meeting token");
-			return
-		}
-
-		let base = new URL(Config.apiBaseURL)
-		let uri = "wss://" + base.hostname + "/ws/meetings/" + this.meetingId + "?meeting_token=" + this.meetingToken;
-
-		this.socket = new WebSocket(uri);
-		this.socket.binaryType = "arraybuffer"
-		this.socket.addEventListener("open", function () {
-			self.onConnected()
-		});
-		this.socket.addEventListener("close", function () {
-			self.onDisconnected()
-		});
-		this.socket.addEventListener("message", function (event) {
-			self.#handleMessage(event.data)
-		});
-		this.socket.addEventListener("error", function (err) {
-			self.onWarningMessage(ErrorCode.ERR_IO, err);
-		});
-	}
-
-	async #handleMessage(msg) {
-		try {
-			if (msg instanceof ArrayBuffer) {
-				let buffer = new Uint8Array(msg)
-				let event = Message.decode(buffer);
-
-				if (event?.update)
-					this.notify('onMeetingUpdate', event.update)
-				if (event?.drawing)
-					this.notify('onDrawing', event.drawing)
-				if (event?.pointer)
-					this.notify('onPointer', event)
-				else if (event?.join)
-					this.notify('onMeetingJoin', event.join)
-				else if (event?.leave)
-					this.notify('onMeetingLeave', event.leave)
-				return
-			}
-		} catch (err) {
-			logger.error(err)
-		}
-
-		try {
-			let Error = JSON.parse(msg);
-			switch (Error.code) {
-				case ErrorCode.ERR_TOO_MANY_CONNECTIONS:
-				case ErrorCode.ERR_UNAUTHORIZED:
-				case ErrorCode.ERR_BAD_REQUEST:
-				case ErrorCode.ERR_TIMEOUT:
-					this.onErrorMessage(Error.code, Error.reason)
-					break
-				default:
-					this.onInfoMessage(Error.code, Error.reason)
-					break
-			}
-		} catch (e) {
-			logger.error(e)
-			this.onWarningMessage(ErrorCode.ERR_IO, msg)
-		}
-	}
-
-	async sendPointer(x, y) {
-		await super.waitForConnection()
-		let claims = await Auth.getUserClaims()
-		let msg = Message.fromObject({
-			pointer: {
-				email: claims.email,
-				x: x,
-				y: y,
-			}
-		})
-
-		let buf = Message.encode(msg).finish();
-		this.socket.send(buf)
-	}
-
-	async sendDrawing({email, data}) {
-		await super.waitForConnection()
-		let msg = Message.fromObject({
-			drawing: {
-				email: email,
-				data: data,
-			}
-		})
-		logger.debug(`${this.getName()}.Drawing: `, Message.toObject(msg))
-
-		let buf = Message.encode(msg).finish();
-		this.socket.send(buf)
-	}
-}
-
-export let MeetingConnection = new MeetingConnectionImp()

package/src/ws/observable_connection.js

@@ -1,84 +0,0 @@
-import {logger} from "../utils/logger/index.js"
-import {ConnectionBase} from "./connection_base.js"
-
-export class ObservableConnection extends ConnectionBase {
-	constructor(connectionName) {
-		super(connectionName)
-		this.observers = new Map()
-	}
-
-	subscribe(id, observer) {
-		this.observers.set(id, observer)
-	}
-
-	unsubscribeAll() {
-		this.observers = new Map()
-	}
-
-	unsubscribe(id) {
-		try {
-			this.observers.delete(id)
-		} catch (err) {
-			logger.error(err)
-		}
-	}
-
-	notify(eventName, ...args) {
-		this.observers.forEach((o) => {
-			try {
-				let fn = o[eventName]
-				if (fn !== undefined) fn(...args)
-			} catch (err) {
-				logger.error(`Error occured notifying event ${eventName}`, err)
-			}
-		})
-	}
-
-	callSubscribers(functionName, ...args) {
-		let promises = []
-
-		this.observers.forEach((o) => {
-			try {
-				let fn = o[functionName]
-				if (fn !== undefined) {
-					let res = fn(...args)
-					promises.push(res)
-				}
-			} catch (error) {
-				logger.error(error)
-			}
-		})
-
-		return Promise.any(promises)
-	}
-
-	onDisconnected() {
-		super.onDisconnected()
-		this.notify("onDisconnected")
-	}
-
-	onConnected() {
-		super.onConnected()
-		this.notify("onConnected")
-	}
-
-	onStopped() {
-		super.onStopped()
-		this.notify("onStopped")
-	}
-
-	onErrorMessage(code, reason) {
-		super.onErrorMessage(code, reason)
-		this.notify("onErrorMessage", code, reason)
-	}
-
-	onWarningMessage(code, reason) {
-		super.onWarningMessage(code, reason)
-		this.notify("onWarningMessage", code, reason)
-	}
-
-	onInfoMessage(code, reason) {
-		super.onInfoMessage(code, reason)
-		this.notify("onInfoMessage", code, reason)
-	}
-}

package/src/ws/retry_connection.js

@@ -1,82 +0,0 @@
-import { logger } from "../utils/logger/index.js"
-import { ObservableConnection } from "./observable_connection.js"
-
-export class RetryConnection extends ObservableConnection {
-	#started
-
-	constructor(connectionName, maxRetryCount = 10, minRetryIntervalMs = 500, maxRetryIntervalMs = 32000) {
-		super(connectionName)
-
-		this.maxRetryCount = maxRetryCount
-		this.minRetryIntervalMs = minRetryIntervalMs
-		this.maxRetryIntervalMs = maxRetryIntervalMs
-		this.retryCount = 0
-		this.retryIntervalMs = minRetryIntervalMs
-		this.lastConnectionTime = Date.now() - maxRetryIntervalMs
-		this.retryTimer = null
-		this.#started = false
-	}
-
-	start() {
-		if (!this.isStarted()) {
-			logger.info(`${this.getName()}: starting...`)
-			this.#started = true
-			this.connect()
-		}
-	}
-
-	stop() {
-		logger.info(`${this.getName()}: stopping...`)
-		this.#started = false
-		this.disconnect()
-	}
-
-	isStarted() {
-		return this.#started
-	}
-
-	onDisconnected() {
-		super.onDisconnected()
-		if (this.isStarted()) this.#reconnect()
-	}
-
-	connect() {
-		if (this.isStarted()) super.connect()
-	}
-
-	disconnect() {
-		if (this.retryTimer) {
-			clearTimeout(this.retryTimer)
-			this.retryTimer = null
-		}
-		super.disconnect()
-	}
-
-	#reconnect() {
-		let self = this
-
-		if (Date.now() - this.lastConnectionTime < this.retryIntervalMs) {
-			this.retryIntervalMs = Math.min(this.retryIntervalMs * 2, this.maxRetryIntervalMs)
-			this.retryCount = this.retryCount + 1
-		} else {
-			this.retryCount = 1
-			this.retryIntervalMs = this.minRetryIntervalMs
-		}
-
-		if (this.retryCount >= this.maxRetryCount) {
-			this.stop()
-			return
-		}
-
-		this.retryTimer = setTimeout(() => {
-			logger.info(`${this.getName()}: retrying connection... [interval: ${this.retryIntervalMs}ms]`)
-			self.lastConnectionTime = Date.now() + 4000
-			self.connect()
-		}, this.retryIntervalMs)
-	}
-
-	onErrorMessage(code, reason) {
-		super.onErrorMessage(code, reason)
-		this.stop()
-	}
-}

package/webpack.config.cjs

@@ -1,144 +0,0 @@
-const path = require('path');
-const webpack = require("webpack")
-
-var BundleAnalyzerPlugin = require("webpack-bundle-analyzer").BundleAnalyzerPlugin
-
-const webConfig = {
-	mode: "production",
-	target: "web",
-	entry: "./src/api/index.js",
-	output: {
-		filename: "jibb.js",
-		path: path.resolve(__dirname, "dist/web"),
-		globalObject: "globalThis",
-		library: {
-			name: "JIBB",
-			type: "umd",
-			export: "default",
-		},
-	},
-	module: {
-		rules: [
-			{
-				test: /\.js$/,
-				exclude: ["/(node_modules)/"],
-				use: {
-					loader: "babel-loader",
-					options: {
-						presets: ["@babel/preset-env"],
-						plugins: [
-							[
-								"babel-plugin-transform-import-ignore",
-								{
-									patterns: ["*xapi*", "**/*.webex-devices.js"],
-								},
-							],
-						],
-					},
-				},
-			},
-		],
-	},
-	plugins: [
-		//	new BundleAnalyzerPlugin(),
-		new webpack.EnvironmentPlugin({
-			API_BASE_URL: "https://api.jibb.ai",
-		}),
-	],
-	externals: { xapi: "xapi" },
-}
-
-const nodeConfig = {
-	target: "node",
-	entry: ["./src/api/index.js"],
-	output: {
-		filename: "jibb.cjs",
-		path: path.resolve(__dirname, "dist/node"),
-		globalObject: "globalThis",
-		library: {
-			name: "JIBB",
-			type: "commonjs",
-			export: "default",
-		},
-	},
-	module: {
-		rules: [
-			{
-				test: /\.js$/,
-				exclude: ["/(node_modules)/", "/utils/http/http.xapi.js"],
-				use: {
-					loader: "babel-loader",
-					options: {
-						presets: ["@babel/preset-env"],
-						plugins: [
-							[
-								"babel-plugin-transform-import-ignore",
-								{
-									patterns: [".webex-devices.js", "*xapi*"],
-								},
-							],
-						],
-					},
-				},
-			},
-		],
-	},
-	externals: { xapi: "xapi" },
-}
-
-const webeXapiConfig = {
-	mode: "production",
-	target: "node",
-	entry: ["./src/index.webex-devices.js"],
-	resolve: {
-		alias: {
-			//	"@jibb/jibbapis/bundle.js": path.resolve(__dirname, `webex_device_specific/jibbapis_replacment.js`),
-		},
-	},
-	output: {
-		filename: "jibb_WebexXapi.js",
-		path: path.resolve(__dirname, "dist/webex"),
-		globalObject: "global",
-		library: {
-			name: "JIBB",
-			type: "umd",
-			export: "default",
-		},
-	},
-	externals: { xapi: "xapi" },
-	externalsPresets: {
-		node: true, // in order to ignore built-in modules like path, fs, etc.
-	},
-	module: {
-		rules: [
-			{
-				test: /\.js$/,
-				exclude: /(node_modules)/,
-				use: {
-					loader: "babel-loader",
-					options: {
-						presets: ["@babel/preset-env"],
-						plugins: [
-							[
-								"babel-plugin-transform-import-ignore",
-								{
-									patterns: ["*axios*"],
-								},
-							],
-						],
-					},
-				},
-			},
-		],
-	},
-
-	plugins: [
-		//	new BundleAnalyzerPlugin(),
-		new webpack.EnvironmentPlugin({
-			API_BASE_URL: "https://api.jibb.ai", // use 'development' unless process.env.NODE_ENV is defined
-		}),
-	],
-}
-
-module.exports = [webConfig, webeXapiConfig, nodeConfig]
-