@dronedeploy/rocos-js-sdk 1.0.0-alpha-2 → 2.6.1

package/grpc/video/pigeon_pb_service.d.ts

@@ -0,0 +1,152 @@
+// package: pigeon.v1
+// file: pigeon.proto
+
+import * as pigeon_pb from "./pigeon_pb";
+import {grpc} from "@improbable-eng/grpc-web";
+
+type operatorconnect = {
+  readonly methodName: string;
+  readonly service: typeof operator;
+  readonly requestStream: false;
+  readonly responseStream: true;
+  readonly requestType: typeof pigeon_pb.OperatorConnectRequest;
+  readonly responseType: typeof pigeon_pb.Message;
+};
+
+type operatorget = {
+  readonly methodName: string;
+  readonly service: typeof operator;
+  readonly requestStream: false;
+  readonly responseStream: false;
+  readonly requestType: typeof pigeon_pb.GetDetailsRequest;
+  readonly responseType: typeof pigeon_pb.GetDetailsResponse;
+};
+
+type operatoroffer = {
+  readonly methodName: string;
+  readonly service: typeof operator;
+  readonly requestStream: false;
+  readonly responseStream: false;
+  readonly requestType: typeof pigeon_pb.OfferRequest;
+  readonly responseType: typeof pigeon_pb.Outcome;
+};
+
+type operatoraddIceCandidate = {
+  readonly methodName: string;
+  readonly service: typeof operator;
+  readonly requestStream: false;
+  readonly responseStream: false;
+  readonly requestType: typeof pigeon_pb.AddIceCandidateRequest;
+  readonly responseType: typeof pigeon_pb.Outcome;
+};
+
+export class operator {
+  static readonly serviceName: string;
+  static readonly connect: operatorconnect;
+  static readonly get: operatorget;
+  static readonly offer: operatoroffer;
+  static readonly addIceCandidate: operatoraddIceCandidate;
+}
+
+type cameraconnect = {
+  readonly methodName: string;
+  readonly service: typeof camera;
+  readonly requestStream: false;
+  readonly responseStream: true;
+  readonly requestType: typeof pigeon_pb.CameraConnectRequest;
+  readonly responseType: typeof pigeon_pb.Message;
+};
+
+type cameraanswer = {
+  readonly methodName: string;
+  readonly service: typeof camera;
+  readonly requestStream: false;
+  readonly responseStream: false;
+  readonly requestType: typeof pigeon_pb.AnswerRequest;
+  readonly responseType: typeof pigeon_pb.Outcome;
+};
+
+export class camera {
+  static readonly serviceName: string;
+  static readonly connect: cameraconnect;
+  static readonly answer: cameraanswer;
+}
+
+export type ServiceError = { message: string, code: number; metadata: grpc.Metadata }
+export type Status = { details: string, code: number; metadata: grpc.Metadata }
+
+interface UnaryResponse {
+  cancel(): void;
+}
+interface ResponseStream<T> {
+  cancel(): void;
+  on(type: 'data', handler: (message: T) => void): ResponseStream<T>;
+  on(type: 'end', handler: (status?: Status) => void): ResponseStream<T>;
+  on(type: 'status', handler: (status: Status) => void): ResponseStream<T>;
+}
+interface RequestStream<T> {
+  write(message: T): RequestStream<T>;
+  end(): void;
+  cancel(): void;
+  on(type: 'end', handler: (status?: Status) => void): RequestStream<T>;
+  on(type: 'status', handler: (status: Status) => void): RequestStream<T>;
+}
+interface BidirectionalStream<ReqT, ResT> {
+  write(message: ReqT): BidirectionalStream<ReqT, ResT>;
+  end(): void;
+  cancel(): void;
+  on(type: 'data', handler: (message: ResT) => void): BidirectionalStream<ReqT, ResT>;
+  on(type: 'end', handler: (status?: Status) => void): BidirectionalStream<ReqT, ResT>;
+  on(type: 'status', handler: (status: Status) => void): BidirectionalStream<ReqT, ResT>;
+}
+
+export class operatorClient {
+  readonly serviceHost: string;
+
+  constructor(serviceHost: string, options?: grpc.RpcOptions);
+  connect(requestMessage: pigeon_pb.OperatorConnectRequest, metadata?: grpc.Metadata): ResponseStream<pigeon_pb.Message>;
+  get(
+    requestMessage: pigeon_pb.GetDetailsRequest,
+    metadata: grpc.Metadata,
+    callback: (error: ServiceError|null, responseMessage: pigeon_pb.GetDetailsResponse|null) => void
+  ): UnaryResponse;
+  get(
+    requestMessage: pigeon_pb.GetDetailsRequest,
+    callback: (error: ServiceError|null, responseMessage: pigeon_pb.GetDetailsResponse|null) => void
+  ): UnaryResponse;
+  offer(
+    requestMessage: pigeon_pb.OfferRequest,
+    metadata: grpc.Metadata,
+    callback: (error: ServiceError|null, responseMessage: pigeon_pb.Outcome|null) => void
+  ): UnaryResponse;
+  offer(
+    requestMessage: pigeon_pb.OfferRequest,
+    callback: (error: ServiceError|null, responseMessage: pigeon_pb.Outcome|null) => void
+  ): UnaryResponse;
+  addIceCandidate(
+    requestMessage: pigeon_pb.AddIceCandidateRequest,
+    metadata: grpc.Metadata,
+    callback: (error: ServiceError|null, responseMessage: pigeon_pb.Outcome|null) => void
+  ): UnaryResponse;
+  addIceCandidate(
+    requestMessage: pigeon_pb.AddIceCandidateRequest,
+    callback: (error: ServiceError|null, responseMessage: pigeon_pb.Outcome|null) => void
+  ): UnaryResponse;
+}
+
+export class cameraClient {
+  readonly serviceHost: string;
+
+  constructor(serviceHost: string, options?: grpc.RpcOptions);
+  connect(requestMessage: pigeon_pb.CameraConnectRequest, metadata?: grpc.Metadata): ResponseStream<pigeon_pb.Message>;
+  answer(
+    requestMessage: pigeon_pb.AnswerRequest,
+    metadata: grpc.Metadata,
+    callback: (error: ServiceError|null, responseMessage: pigeon_pb.Outcome|null) => void
+  ): UnaryResponse;
+  answer(
+    requestMessage: pigeon_pb.AnswerRequest,
+    callback: (error: ServiceError|null, responseMessage: pigeon_pb.Outcome|null) => void
+  ): UnaryResponse;
+}
+

package/grpc/video/pigeon_pb_service.js

@@ -0,0 +1,292 @@
+// package: pigeon.v1
+// file: pigeon.proto
+
+var pigeon_pb = require("./pigeon_pb");
+var grpc = require("@improbable-eng/grpc-web").grpc;
+
+var operator = (function () {
+  function operator() {}
+  operator.serviceName = "pigeon.v1.operator";
+  return operator;
+}());
+
+operator.connect = {
+  methodName: "connect",
+  service: operator,
+  requestStream: false,
+  responseStream: true,
+  requestType: pigeon_pb.OperatorConnectRequest,
+  responseType: pigeon_pb.Message
+};
+
+operator.get = {
+  methodName: "get",
+  service: operator,
+  requestStream: false,
+  responseStream: false,
+  requestType: pigeon_pb.GetDetailsRequest,
+  responseType: pigeon_pb.GetDetailsResponse
+};
+
+operator.offer = {
+  methodName: "offer",
+  service: operator,
+  requestStream: false,
+  responseStream: false,
+  requestType: pigeon_pb.OfferRequest,
+  responseType: pigeon_pb.Outcome
+};
+
+operator.addIceCandidate = {
+  methodName: "addIceCandidate",
+  service: operator,
+  requestStream: false,
+  responseStream: false,
+  requestType: pigeon_pb.AddIceCandidateRequest,
+  responseType: pigeon_pb.Outcome
+};
+
+exports.operator = operator;
+
+function operatorClient(serviceHost, options) {
+  this.serviceHost = serviceHost;
+  this.options = options || {};
+}
+
+operatorClient.prototype.connect = function connect(requestMessage, metadata) {
+  var listeners = {
+    data: [],
+    end: [],
+    status: []
+  };
+  var client = grpc.invoke(operator.connect, {
+    request: requestMessage,
+    host: this.serviceHost,
+    metadata: metadata,
+    transport: this.options.transport,
+    debug: this.options.debug,
+    onMessage: function (responseMessage) {
+      listeners.data.forEach(function (handler) {
+        handler(responseMessage);
+      });
+    },
+    onEnd: function (status, statusMessage, trailers) {
+      listeners.status.forEach(function (handler) {
+        handler({ code: status, details: statusMessage, metadata: trailers });
+      });
+      listeners.end.forEach(function (handler) {
+        handler({ code: status, details: statusMessage, metadata: trailers });
+      });
+      listeners = null;
+    }
+  });
+  return {
+    on: function (type, handler) {
+      listeners[type].push(handler);
+      return this;
+    },
+    cancel: function () {
+      listeners = null;
+      client.close();
+    }
+  };
+};
+
+operatorClient.prototype.get = function get(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(operator.get, {
+    request: requestMessage,
+    host: this.serviceHost,
+    metadata: metadata,
+    transport: this.options.transport,
+    debug: this.options.debug,
+    onEnd: function (response) {
+      if (callback) {
+        if (response.status !== grpc.Code.OK) {
+          var err = new Error(response.statusMessage);
+          err.code = response.status;
+          err.metadata = response.trailers;
+          callback(err, null);
+        } else {
+          callback(null, response.message);
+        }
+      }
+    }
+  });
+  return {
+    cancel: function () {
+      callback = null;
+      client.close();
+    }
+  };
+};
+
+operatorClient.prototype.offer = function offer(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(operator.offer, {
+    request: requestMessage,
+    host: this.serviceHost,
+    metadata: metadata,
+    transport: this.options.transport,
+    debug: this.options.debug,
+    onEnd: function (response) {
+      if (callback) {
+        if (response.status !== grpc.Code.OK) {
+          var err = new Error(response.statusMessage);
+          err.code = response.status;
+          err.metadata = response.trailers;
+          callback(err, null);
+        } else {
+          callback(null, response.message);
+        }
+      }
+    }
+  });
+  return {
+    cancel: function () {
+      callback = null;
+      client.close();
+    }
+  };
+};
+
+operatorClient.prototype.addIceCandidate = function addIceCandidate(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(operator.addIceCandidate, {
+    request: requestMessage,
+    host: this.serviceHost,
+    metadata: metadata,
+    transport: this.options.transport,
+    debug: this.options.debug,
+    onEnd: function (response) {
+      if (callback) {
+        if (response.status !== grpc.Code.OK) {
+          var err = new Error(response.statusMessage);
+          err.code = response.status;
+          err.metadata = response.trailers;
+          callback(err, null);
+        } else {
+          callback(null, response.message);
+        }
+      }
+    }
+  });
+  return {
+    cancel: function () {
+      callback = null;
+      client.close();
+    }
+  };
+};
+
+exports.operatorClient = operatorClient;
+
+var camera = (function () {
+  function camera() {}
+  camera.serviceName = "pigeon.v1.camera";
+  return camera;
+}());
+
+camera.connect = {
+  methodName: "connect",
+  service: camera,
+  requestStream: false,
+  responseStream: true,
+  requestType: pigeon_pb.CameraConnectRequest,
+  responseType: pigeon_pb.Message
+};
+
+camera.answer = {
+  methodName: "answer",
+  service: camera,
+  requestStream: false,
+  responseStream: false,
+  requestType: pigeon_pb.AnswerRequest,
+  responseType: pigeon_pb.Outcome
+};
+
+exports.camera = camera;
+
+function cameraClient(serviceHost, options) {
+  this.serviceHost = serviceHost;
+  this.options = options || {};
+}
+
+cameraClient.prototype.connect = function connect(requestMessage, metadata) {
+  var listeners = {
+    data: [],
+    end: [],
+    status: []
+  };
+  var client = grpc.invoke(camera.connect, {
+    request: requestMessage,
+    host: this.serviceHost,
+    metadata: metadata,
+    transport: this.options.transport,
+    debug: this.options.debug,
+    onMessage: function (responseMessage) {
+      listeners.data.forEach(function (handler) {
+        handler(responseMessage);
+      });
+    },
+    onEnd: function (status, statusMessage, trailers) {
+      listeners.status.forEach(function (handler) {
+        handler({ code: status, details: statusMessage, metadata: trailers });
+      });
+      listeners.end.forEach(function (handler) {
+        handler({ code: status, details: statusMessage, metadata: trailers });
+      });
+      listeners = null;
+    }
+  });
+  return {
+    on: function (type, handler) {
+      listeners[type].push(handler);
+      return this;
+    },
+    cancel: function () {
+      listeners = null;
+      client.close();
+    }
+  };
+};
+
+cameraClient.prototype.answer = function answer(requestMessage, metadata, callback) {
+  if (arguments.length === 2) {
+    callback = arguments[1];
+  }
+  var client = grpc.unary(camera.answer, {
+    request: requestMessage,
+    host: this.serviceHost,
+    metadata: metadata,
+    transport: this.options.transport,
+    debug: this.options.debug,
+    onEnd: function (response) {
+      if (callback) {
+        if (response.status !== grpc.Code.OK) {
+          var err = new Error(response.statusMessage);
+          err.code = response.status;
+          err.metadata = response.trailers;
+          callback(err, null);
+        } else {
+          callback(null, response.message);
+        }
+      }
+    }
+  });
+  return {
+    cancel: function () {
+      callback = null;
+      client.close();
+    }
+  };
+};
+
+exports.cameraClient = cameraClient;
+

package/helpers/arrayRemove.js

@@ -1,3 +1,7 @@
-export const arrayRemove = (original, remove) => {
-    return original?.filter((v) => remove.indexOf(v) === -1);
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.arrayRemove = void 0;
+const arrayRemove = (original, remove) => {
+    return original === null || original === void 0 ? void 0 : original.filter((v) => remove.indexOf(v) === -1);
 };
+exports.arrayRemove = arrayRemove;

package/helpers/arrayUnique.js

@@ -1,3 +1,7 @@
-export const arrayUnique = (data) => {
-    return data?.filter((v, i, a) => a.indexOf(v) === i);
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.arrayUnique = void 0;
+const arrayUnique = (data) => {
+    return data === null || data === void 0 ? void 0 : data.filter((v, i, a) => a.indexOf(v) === i);
 };
+exports.arrayUnique = arrayUnique;

package/helpers/average.js

@@ -1,6 +1,11 @@
-export const average = (numbers) => {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.average = void 0;
+const average = (numbers) => {
     const sum = numbers.reduce((numberSum, value) => {
         return numberSum + value;
     }, 0);
-    return sum / numbers.length;
+    const avg = sum / numbers.length;
+    return avg;
 };
+exports.average = average;

package/helpers/cleanObject.js

@@ -1,18 +1,20 @@
-export const cleanObject = (object) => {
-    return {
-        ...(function _flatten(o) {
-            return [...Object.entries(o)].reduce((obj, [key, val]) => {
-                if (typeof val === 'object') {
-                    obj[key] = _flatten(val);
-                }
-                else if (typeof val === 'function') {
-                    delete obj[key];
-                }
-                else {
-                    obj[key] = val;
-                }
-                return obj;
-            }, Array.isArray(o) ? [] : {});
-        })(object),
-    };
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cleanObject = void 0;
+const cleanObject = (object) => {
+    return Object.assign({}, (function _flatten(o) {
+        return [...Object.entries(o)].reduce((obj, [key, val]) => {
+            if (typeof val === 'object') {
+                obj[key] = _flatten(val);
+            }
+            else if (typeof val === 'function') {
+                delete obj[key];
+            }
+            else {
+                obj[key] = val;
+            }
+            return obj;
+        }, Array.isArray(o) ? [] : {});
+    })(object));
 };
+exports.cleanObject = cleanObject;

package/helpers/enviroment.js

@@ -1,13 +1,20 @@
+"use strict";
 /* global window self */
-export const isBrowser = typeof window !== 'undefined' && typeof window.document !== 'undefined';
-export const isWebWorker = typeof self === 'object' && self.constructor && self.constructor.name === 'DedicatedWorkerGlobalScope';
-export const isNode = typeof process !== 'undefined' && process.versions != null && process.versions.node != null;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isJsDom = exports.isNode = exports.isWebWorker = exports.isBrowser = void 0;
+exports.isBrowser = typeof window !== 'undefined' && typeof window.document !== 'undefined';
+/* eslint-disable no-restricted-globals */
+exports.isWebWorker = typeof self === 'object' && self.constructor && self.constructor.name === 'DedicatedWorkerGlobalScope';
+/* eslint-enable no-restricted-globals */
+exports.isNode = typeof process !== 'undefined' && process.versions != null && process.versions.node != null;
 /**
  * @see https://github.com/jsdom/jsdom/releases/tag/12.0.0
  * @see https://github.com/jsdom/jsdom/issues/1537
  */
-export const isJsDom = () => {
+/* eslint-disable no-undef */
+const isJsDom = () => {
     return ((typeof window !== 'undefined' && window.name === 'nodejs') ||
         navigator.userAgent.includes('Node.js') ||
         navigator.userAgent.includes('jsdom'));
 };
+exports.isJsDom = isJsDom;

package/helpers/flattenCallsignsLookup.d.ts

@@ -1,2 +1,2 @@
-import { CallsignsLookup } from '../models';
+import { CallsignsLookup } from '../models/callsigns/CallsignsLookup';
 export declare const flattenCallsignsLookup: (callsignsLookup: CallsignsLookup | string[]) => string[];

package/helpers/flattenCallsignsLookup.js

@@ -1,6 +1,10 @@
-export const flattenCallsignsLookup = (callsignsLookup) => {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.flattenCallsignsLookup = void 0;
+const flattenCallsignsLookup = (callsignsLookup) => {
     if (callsignsLookup.lookupValue) {
         return callsignsLookup.toID();
     }
     return callsignsLookup.sort();
 };
+exports.flattenCallsignsLookup = flattenCallsignsLookup;

package/helpers/flattenObject.js

@@ -1,4 +1,7 @@
-export const flattenObject = (object) => {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.flattenObject = void 0;
+const flattenObject = (object) => {
     return Object.assign({}, ...(function _flatten(o) {
         return [].concat(...Object.keys(o).map((k) => {
             if (typeof o[k] === 'object') {
@@ -11,3 +14,4 @@ export const flattenObject = (object) => {
         }));
     })(object));
 };
+exports.flattenObject = flattenObject;

package/helpers/formatServiceUrl.js

@@ -1,7 +1,11 @@
-export const formatServiceUrl = (url, params, insecure = false) => {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatServiceUrl = void 0;
+const formatServiceUrl = (url, params, insecure = false) => {
     let formattedUrl = insecure ? url.replace('https:', 'http:') : url;
     for (const item of Object.keys(params)) {
         formattedUrl = formattedUrl.replace(`{${item}}`, params[item]);
     }
     return formattedUrl;
 };
+exports.formatServiceUrl = formatServiceUrl;

package/helpers/generateUUID.js

@@ -1,4 +1,8 @@
-import { v4 as uuidv4 } from 'uuid';
-export const generateUUID = () => {
-    return uuidv4();
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateUUID = void 0;
+const uuid_1 = require("uuid");
+const generateUUID = () => {
+    return uuid_1.v4();
 };
+exports.generateUUID = generateUUID;

package/helpers/getSubscriptionsDifference.d.ts

@@ -1,8 +1,8 @@
-type ISubscriptionsDifferenceRecord = {
+declare type ISubscriptionsDifferenceRecord = {
     callsigns: string[];
-    sources: string[];
+    sources: any;
 };
-type ISubscriptionsDifference = {
+declare type ISubscriptionsDifference = {
     toRemove: ISubscriptionsDifferenceRecord;
     toAdd: ISubscriptionsDifferenceRecord;
 };

package/helpers/getSubscriptionsDifference.js

@@ -1,10 +1,13 @@
-import { arrayRemove } from './arrayRemove';
-export const getSubscriptionsDifference = (before, after) => {
-    const toRemove = { ...before };
-    const toAdd = { ...after };
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSubscriptionsDifference = void 0;
+const arrayRemove_1 = require("./arrayRemove");
+const getSubscriptionsDifference = (before, after) => {
+    const toRemove = Object.assign({}, before);
+    const toAdd = Object.assign({}, after);
     Object.keys(before).forEach((key) => {
         if (after[key]) {
-            toRemove[key] = arrayRemove(toRemove[key], after[key]);
+            toRemove[key] = arrayRemove_1.arrayRemove(toRemove[key], after[key]);
             if (!toRemove[key].length) {
                 delete toRemove[key];
             }
@@ -12,7 +15,7 @@ export const getSubscriptionsDifference = (before, after) => {
     });
     Object.keys(after).forEach((key) => {
         if (before[key]) {
-            toAdd[key] = arrayRemove(toAdd[key], before[key]);
+            toAdd[key] = arrayRemove_1.arrayRemove(toAdd[key], before[key]);
             if (!toAdd[key].length) {
                 delete toAdd[key];
             }
@@ -33,3 +36,4 @@ export const getSubscriptionsDifference = (before, after) => {
         },
     };
 };
+exports.getSubscriptionsDifference = getSubscriptionsDifference;

package/helpers/getUniqueConfigKey.js

@@ -1,14 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getUniqueConfigKey = void 0;
 /**
  * Flattens and orders the sdk config props to make a unique key
  *
  * @param config - SDK config {@link IRocosSDKConfig}
  */
-export const getUniqueConfigKey = (config) => {
+const getUniqueConfigKey = (config) => {
     return Object.keys(config)
         .sort()
         .map((item) => {
+        // @ts-ignore
         return item !== 'token' ? `${item}:${config[item]}` : false;
     })
         .filter(Boolean)
         .join();
 };
+exports.getUniqueConfigKey = getUniqueConfigKey;