@exotel-npm-dev/webrtc-client-sdk 1.0.0

package/src/api/omAPI/FSM.js

@@ -0,0 +1,126 @@
+// JS Finite State Machine
+//
+// A simple finite state machine library for code flow and transition control.
+//
+// https://github.com/jhund/js-finite-state-machine
+// Copyright (c)2011 Jo Hund, ClearCove Software Inc.
+// Based originally on FSM by Anthony Blackshaw <ant@getme.co.uk> (www.getme.co.uk) Copyright (c)2008
+
+
+// Initializes a new state machine.
+// Usage: var fsm = new FSM("initial", { d1: "foo", d2: "bar" });
+//
+// param [String] initialState the initial state of the state machine
+// param [Object, optional] data data specific to this state machine. Is available as this.data in
+//   callbacks
+function FSM(initialState, data) {
+    this.stateTransitions = {};
+    this.stateTransitionsFromAnyState = {};
+    this.defaultTransition = null;
+    this.currentState = initialState;
+    this.data = data;
+    this.debug = true; // set to true to turn on console output for debugging (see function "sendEvent")
+};
+
+
+// Specify a "specific" transition for given events and currentStates.
+//
+// param [String, Array<String>] events the event(s) that trigger the transition.
+// param [String, Array<String>] currentStates the state(s) that respond to the given event
+// param [Function, null] callback the callback will be called before the transition happens
+// param [String] nextState the state after the transition
+FSM.prototype.addTransition = function(events, currentStates, callback, nextState) {
+  if(typeof(events) === 'string') { events = [events]; }
+  if(typeof(currentStates) === 'string') { currentStates = [currentStates]; }
+  for (var i = 0; i < events.length; i++) {
+    for (var j = 0; j < currentStates.length; j++) {
+      if (!nextState) { nextState = currentStates[j]; } // stay in state if no nextState given
+      this.stateTransitions[ [events[i], currentStates[j]] ] = [callback, nextState];
+    }
+  }
+};
+
+
+// Specify a "from any state" transition. This is applied if no specific transition is
+// found for the currentState and event given
+//
+// param [String, Array<String>] events the event(s) that trigger the transition.
+// param [Function, null] callback the callback will be called before the transition happens
+// param [String] nextState the state after the transition
+FSM.prototype.addTransitionFromAnyState = function(events, callback, nextState) {
+  if(typeof(events) === 'string') { events = [events]; }
+  for (var i = 0; i < events.length; i++) {
+    this.stateTransitionsFromAnyState[ events[i] ] = [callback, nextState];
+  }
+};
+
+
+// Specify a "default" transition. This is applied if no other matching transition is
+// found for the currentState and given event
+//
+// param [Function, null] callback the callback(s) will be called before the transition happens
+// param [String] nextState the state after the transition
+FSM.prototype.setDefaultTransition = function(callback, nextState) {
+  this.defaultTransition = [callback, nextState];
+};
+
+
+// Get the transition for the currentState and event given.
+// Based on the current state and the event given, the state machine applies the first matching
+// transition in the following order:
+// * "specific" (for given currentState and event)
+// * "from any state" (for given event)
+// * "default" (if no matching transitions are found by now)
+//
+// param [String] event the event
+// param [String] state the state
+// return [Transition] the matching transition. [Callback, NextState]
+FSM.prototype.getTransition = function(event, state) {
+  var r;
+  r = this.stateTransitions[[event, state]] || // first try "specific"
+      this.stateTransitionsFromAnyState[event] || // then try "from any state"
+      this.defaultTransition // lastly try default transition
+  if (r) {
+    // return [callback, newState] tuple. Stay in currentState if no nextState given
+    return [r[0], r[1] || this.currentState]
+  } else {
+    throw Error("Transition is undefined: (" + event + ", " + state + ")");
+  }
+};
+
+
+// Send an event to the state machine to trigger a transition.
+//
+// param [String] event the event to send to the state machine
+// param [Object, optional] eventData data specific for this event. Available as eventData in
+//   callback
+FSM.prototype.sendEvent = function(event, eventData) {
+  var result = this.getTransition(event, this.currentState),
+      currentState = this.currentState,
+      newState,
+      callback,
+      debugMsg;
+  newState = result[1];
+  callback = result[0];
+
+  if (this.debug && window.console && window.console.log) {
+    debugMsg = [];
+    if (this.data.name) {
+      debugMsg.push(this.data.name + ': ');
+    } else {
+      debugMsg.push('FSM: ');
+    }
+    debugMsg.push(event + ': ');
+    debugMsg.push(currentState + ' -> ' + newState);
+    if (eventData) { debugMsg.push('; with event data'); }
+    if (callback) { debugMsg.push('; with callback'); }
+    window.console.log(debugMsg.join(''));
+  };
+
+  this.currentState = newState;
+  this.action = callback;
+  if (callback) {
+    callback.call(this, eventData); // call callback in state_machine context
+  }
+
+};

package/src/api/omAPI/WebrtcLogger.js

@@ -0,0 +1,55 @@
+/* ES6 LOGGER */
+/*
+import Logger from 'node-logger-es6'
+
+var es6Logger = Logger.configure(
+    {
+        level: 'debug',
+        rotation: 'd',
+        size: 5,
+        json: true,
+        timestamp: true
+    }
+); 
+*/
+
+/* CUSTOM-LOGGER */
+/* Note currently customLogger uses console only
+   we can replace it with any other logger for 
+   instances: es6Logger or ameyoLogger or winstonLogger.
+   essentially the idea is not to duplicate the logic of 
+   handling levels and output stream.
+ */
+export var customLogger =  {
+
+  log : (arg1, ...args) => {
+    console.log(arg1, args)
+  },
+
+  info : (arg1, ...args) => {
+    console.log(arg1, args)
+  },  
+
+  warn : (arg1, ...args) => {
+    console.log(arg1, args)
+  },
+
+  error : (arg1, ...args) => {
+    console.log(arg1, args)
+  }  
+
+}; 
+
+/* CONSOLE LOGGER */
+var consoleLogger = console;
+
+/* FINAL LOGGER TO USE */
+export function webrtcLogger() {
+    if (customLogger) {
+      return customLogger;
+    } else {
+      return consoleLogger;
+    }
+} 
+
+

package/src/api/omAPI/js-finite-state-machine.js

@@ -0,0 +1,126 @@
+// JS Finite State Machine
+//
+// A simple finite state machine library for code flow and transition control.
+//
+// https://github.com/jhund/js-finite-state-machine
+// Copyright (c)2011 Jo Hund, ClearCove Software Inc.
+// Based originally on FSM by Anthony Blackshaw <ant@getme.co.uk> (www.getme.co.uk) Copyright (c)2008
+
+
+// Initializes a new state machine.
+// Usage: var fsm = new FSM("initial", { d1: "foo", d2: "bar" });
+//
+// param [String] initialState the initial state of the state machine
+// param [Object, optional] data data specific to this state machine. Is available as this.data in
+//   callbacks
+function FSM(initialState, data) {
+    this.stateTransitions = {};
+    this.stateTransitionsFromAnyState = {};
+    this.defaultTransition = null;
+    this.currentState = initialState;
+    this.data = data;
+    this.debug = true; // set to true to turn on console output for debugging (see function "sendEvent")
+};
+
+
+// Specify a "specific" transition for given events and currentStates.
+//
+// param [String, Array<String>] events the event(s) that trigger the transition.
+// param [String, Array<String>] currentStates the state(s) that respond to the given event
+// param [Function, null] callback the callback will be called before the transition happens
+// param [String] nextState the state after the transition
+FSM.prototype.addTransition = function(events, currentStates, callback, nextState) {
+  if(typeof(events) === 'string') { events = [events]; }
+  if(typeof(currentStates) === 'string') { currentStates = [currentStates]; }
+  for (var i = 0; i < events.length; i++) {
+    for (var j = 0; j < currentStates.length; j++) {
+      if (!nextState) { nextState = currentStates[j]; } // stay in state if no nextState given
+      this.stateTransitions[ [events[i], currentStates[j]] ] = [callback, nextState];
+    }
+  }
+};
+
+
+// Specify a "from any state" transition. This is applied if no specific transition is
+// found for the currentState and event given
+//
+// param [String, Array<String>] events the event(s) that trigger the transition.
+// param [Function, null] callback the callback will be called before the transition happens
+// param [String] nextState the state after the transition
+FSM.prototype.addTransitionFromAnyState = function(events, callback, nextState) {
+  if(typeof(events) === 'string') { events = [events]; }
+  for (var i = 0; i < events.length; i++) {
+    this.stateTransitionsFromAnyState[ events[i] ] = [callback, nextState];
+  }
+};
+
+
+// Specify a "default" transition. This is applied if no other matching transition is
+// found for the currentState and given event
+//
+// param [Function, null] callback the callback(s) will be called before the transition happens
+// param [String] nextState the state after the transition
+FSM.prototype.setDefaultTransition = function(callback, nextState) {
+  this.defaultTransition = [callback, nextState];
+};
+
+
+// Get the transition for the currentState and event given.
+// Based on the current state and the event given, the state machine applies the first matching
+// transition in the following order:
+// * "specific" (for given currentState and event)
+// * "from any state" (for given event)
+// * "default" (if no matching transitions are found by now)
+//
+// param [String] event the event
+// param [String] state the state
+// return [Transition] the matching transition. [Callback, NextState]
+FSM.prototype.getTransition = function(event, state) {
+  var r;
+  r = this.stateTransitions[[event, state]] || // first try "specific"
+      this.stateTransitionsFromAnyState[event] || // then try "from any state"
+      this.defaultTransition // lastly try default transition
+  if (r) {
+    // return [callback, newState] tuple. Stay in currentState if no nextState given
+    return [r[0], r[1] || this.currentState]
+  } else {
+    throw Error("Transition is undefined: (" + event + ", " + state + ")");
+  }
+};
+
+
+// Send an event to the state machine to trigger a transition.
+//
+// param [String] event the event to send to the state machine
+// param [Object, optional] eventData data specific for this event. Available as eventData in
+//   callback
+FSM.prototype.sendEvent = function(event, eventData) {
+  var result = this.getTransition(event, this.currentState),
+      currentState = this.currentState,
+      newState,
+      callback,
+      debugMsg;
+  newState = result[1];
+  callback = result[0];
+
+  if (this.debug && window.console && window.console.log) {
+    debugMsg = [];
+    if (this.data.name) {
+      debugMsg.push(this.data.name + ': ');
+    } else {
+      debugMsg.push('FSM: ');
+    }
+    debugMsg.push(event + ': ');
+    debugMsg.push(currentState + ' -> ' + newState);
+    if (eventData) { debugMsg.push('; with event data'); }
+    if (callback) { debugMsg.push('; with callback'); }
+    window.console.log(debugMsg.join(''));
+  };
+
+  this.currentState = newState;
+  this.action = callback;
+  if (callback) {
+    callback.call(this, eventData); // call callback in state_machine context
+  }
+
+};

package/src/api/omAPI/log/index.js

@@ -0,0 +1,8 @@
+"use strict";
+function __export(m) {
+    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
+}
+Object.defineProperty(exports, "__esModule", { value: true });
+__export(require("./levels"));
+__export(require("./logger-factory"));
+__export(require("./logger"));

package/src/api/omAPI/log/index.ts

@@ -0,0 +1,3 @@
+export * from "./levels";
+export * from "./logger-factory";
+export * from "./logger";

package/src/api/omAPI/log/levels.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Log levels.
+ * @public
+ */
+var Levels;
+(function (Levels) {
+    Levels[Levels["error"] = 0] = "error";
+    Levels[Levels["warn"] = 1] = "warn";
+    Levels[Levels["log"] = 2] = "log";
+    Levels[Levels["debug"] = 3] = "debug";
+})(Levels = exports.Levels || (exports.Levels = {}));

package/src/api/omAPI/log/levels.ts

@@ -0,0 +1,10 @@
+/**
+ * Log levels.
+ * @public
+ */
+export enum Levels {
+  error,
+  warn,
+  log,
+  debug
+}

package/src/api/omAPI/log/logger-factory.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var levels_1 = require("./levels");
+var logger_1 = require("./logger");
+/**
+ * Logger.
+ * @public
+ */
+var LoggerFactory = /** @class */ (function () {
+    function LoggerFactory() {
+        this.builtinEnabled = true;
+        this._level = levels_1.Levels.log;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        this.loggers = {};
+        this.logger = this.getLogger("Exotel.WebrtcLib");
+    }
+    Object.defineProperty(LoggerFactory.prototype, "level", {
+        get: function () {
+            return this._level;
+        },
+        set: function (newLevel) {
+            if (newLevel >= 0 && newLevel <= 3) {
+                this._level = newLevel;
+            }
+            else if (newLevel > 3) {
+                this._level = 3;
+                // eslint-disable-next-line no-prototype-builtins
+            }
+            else if (levels_1.Levels.hasOwnProperty(newLevel)) {
+                this._level = newLevel;
+            }
+            else {
+                this.logger.error("invalid 'level' parameter value: " + JSON.stringify(newLevel));
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(LoggerFactory.prototype, "connector", {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        get: function () {
+            return this._connector;
+        },
+        set: function (value) {
+            if (!value) {
+                this._connector = undefined;
+            }
+            else if (typeof value === "function") {
+                this._connector = value;
+            }
+            else {
+                this.logger.error("invalid 'connector' parameter value: " + JSON.stringify(value));
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    LoggerFactory.prototype.getLogger = function (category, label) {
+        if (label && this.level === 3) {
+            return new logger_1.Logger(this, category, label);
+        }
+        else if (this.loggers[category]) {
+            return this.loggers[category];
+        }
+        else {
+            var logger = new logger_1.Logger(this, category);
+            this.loggers[category] = logger;
+            return logger;
+        }
+    };
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    LoggerFactory.prototype.genericLog = function (levelToLog, category, label, content) {
+        if (this.level >= levelToLog) {
+            if (this.builtinEnabled) {
+                this.print(levelToLog, category, label, content);
+            }
+        }
+        if (this.connector) {
+            this.connector(levels_1.Levels[levelToLog], category, label, content);
+        }
+    };
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    LoggerFactory.prototype.print = function (levelToLog, category, label, content) {
+        if (typeof content === "string") {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            var prefix = [new Date(), category];
+            if (label) {
+                prefix.push(label);
+            }
+            content = prefix.concat(content).join(" | ");
+        }
+        switch (levelToLog) {
+            case levels_1.Levels.error:
+                // eslint-disable-next-line no-console
+                console.error(content);
+                break;
+            case levels_1.Levels.warn:
+                // eslint-disable-next-line no-console
+                console.warn(content);
+                break;
+            case levels_1.Levels.log:
+                // eslint-disable-next-line no-console
+                console.log(content);
+                break;
+            case levels_1.Levels.debug:
+                // eslint-disable-next-line no-console
+                console.debug(content);
+                break;
+            default:
+                break;
+        }
+    };
+    return LoggerFactory;
+}());
+exports.LoggerFactory = LoggerFactory;

package/src/api/omAPI/log/logger-factory.ts

@@ -0,0 +1,119 @@
+import { Levels } from "./levels";
+import { Logger } from "./logger";
+
+/**
+ * Logger.
+ * @public
+ */
+export class LoggerFactory {
+  public builtinEnabled = true;
+
+  private _level: Levels = Levels.log;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  private _connector: ((level: string, category: string, label: string | undefined, content: any) => void) | undefined;
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  private loggers: any = {};
+  private logger: Logger;
+
+  constructor() {
+    this.logger = this.getLogger("Exotel.WebrtcLib");
+  }
+
+  get level(): Levels {
+    return this._level;
+  }
+  set level(newLevel: Levels) {
+    if (newLevel >= 0 && newLevel <= 3) {
+      this._level = newLevel;
+    } else if (newLevel > 3) {
+      this._level = 3;
+      // eslint-disable-next-line no-prototype-builtins
+    } else if (Levels.hasOwnProperty(newLevel)) {
+      this._level = newLevel;
+    } else {
+      this.logger.error("invalid 'level' parameter value: " + JSON.stringify(newLevel));
+    }
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  get connector(): ((level: string, category: string, label: string | undefined, content: any) => void) | undefined {
+    return this._connector;
+  }
+  set connector(
+    value:
+      | ((
+          level: string,
+          category: string,
+          label: string | undefined,
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          content: any
+        ) => void)
+      | undefined
+  ) {
+    if (!value) {
+      this._connector = undefined;
+    } else if (typeof value === "function") {
+      this._connector = value;
+    } else {
+      this.logger.error("invalid 'connector' parameter value: " + JSON.stringify(value));
+    }
+  }
+
+  public getLogger(category: string, label?: string): Logger {
+    if (label && this.level === 3) {
+      return new Logger(this, category, label);
+    } else if (this.loggers[category]) {
+      return this.loggers[category];
+    } else {
+      const logger = new Logger(this, category);
+      this.loggers[category] = logger;
+      return logger;
+    }
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  public genericLog(levelToLog: Levels, category: string, label: string | undefined, content: any): void {
+    if (this.level >= levelToLog) {
+      if (this.builtinEnabled) {
+        this.print(levelToLog, category, label, content);
+      }
+    }
+
+    if (this.connector) {
+      this.connector(Levels[levelToLog], category, label, content);
+    }
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  private print(levelToLog: Levels, category: string, label: string | undefined, content: any): void {
+    if (typeof content === "string") {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      const prefix: Array<any> = [new Date(), category];
+      if (label) {
+        prefix.push(label);
+      }
+      content = prefix.concat(content).join(" | ");
+    }
+    switch (levelToLog) {
+      case Levels.error:
+        // eslint-disable-next-line no-console
+        console.error(content);
+        break;
+      case Levels.warn:
+        // eslint-disable-next-line no-console
+        console.warn(content);
+        break;
+      case Levels.log:
+        // eslint-disable-next-line no-console
+        console.log(content);
+        break;
+      case Levels.debug:
+        // eslint-disable-next-line no-console
+        console.debug(content);
+        break;
+      default:
+        break;
+    }
+  }
+}

package/src/api/omAPI/log/logger.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var levels_1 = require("./levels");
+/**
+ * Logger.
+ * @public
+ */
+var Logger = /** @class */ (function () {
+    function Logger(logger, category, label) {
+        this.logger = logger;
+        this.category = category;
+        this.label = label;
+    }
+    Logger.prototype.error = function (content) {
+        this.genericLog(levels_1.Levels.error, content);
+    };
+    Logger.prototype.warn = function (content) {
+        this.genericLog(levels_1.Levels.warn, content);
+    };
+    Logger.prototype.log = function (content) {
+        this.genericLog(levels_1.Levels.log, content);
+    };
+    Logger.prototype.debug = function (content) {
+        this.genericLog(levels_1.Levels.debug, content);
+    };
+    Logger.prototype.genericLog = function (level, content) {
+        this.logger.genericLog(level, this.category, this.label, content);
+    };
+    Object.defineProperty(Logger.prototype, "level", {
+        get: function () {
+            return this.logger.level;
+        },
+        set: function (newLevel) {
+            this.logger.level = newLevel;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    return Logger;
+}());
+exports.Logger = Logger;

package/src/api/omAPI/log/logger.ts

@@ -0,0 +1,42 @@
+import { Levels } from "./levels";
+import { LoggerFactory } from "./logger-factory";
+
+/**
+ * Logger.
+ * @public
+ */
+export class Logger {
+  private logger: LoggerFactory;
+  private category: string;
+  private label: string | undefined;
+
+  constructor(logger: LoggerFactory, category: string, label?: string) {
+    this.logger = logger;
+    this.category = category;
+    this.label = label;
+  }
+
+  public error(content: string): void {
+    this.genericLog(Levels.error, content);
+  }
+  public warn(content: string): void {
+    this.genericLog(Levels.warn, content);
+  }
+  public log(content: string): void {
+    this.genericLog(Levels.log, content);
+  }
+  public debug(content: string): void {
+    this.genericLog(Levels.debug, content);
+  }
+
+  private genericLog(level: Levels, content: string): void {
+    this.logger.genericLog(level, this.category, this.label, content);
+  }
+
+  get level(): Levels {
+    return this.logger.level;
+  }
+  set level(newLevel: Levels) {
+    this.logger.level = newLevel;
+  }
+}