@dronedeploy/rocos-js-sdk 0.0.1 → 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.d.ts

@@ -0,0 +1 @@
+export declare const arrayRemove: (original: string[], remove: string[]) => string[];

package/helpers/arrayRemove.js

@@ -0,0 +1,7 @@
+"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.d.ts

@@ -0,0 +1 @@
+export declare const arrayUnique: (data: string[]) => string[];

package/helpers/arrayUnique.js

@@ -0,0 +1,7 @@
+"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.d.ts

@@ -0,0 +1 @@
+export declare const average: (numbers: number[]) => number;

package/helpers/average.js

@@ -0,0 +1,11 @@
+"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);
+    const avg = sum / numbers.length;
+    return avg;
+};
+exports.average = average;

package/helpers/cleanObject.d.ts

@@ -0,0 +1 @@
+export declare const cleanObject: <T>(object: T) => T;

package/helpers/cleanObject.js

@@ -0,0 +1,20 @@
+"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.d.ts

@@ -0,0 +1,8 @@
+export declare const isBrowser: boolean;
+export declare const isWebWorker: boolean;
+export declare const isNode: boolean;
+/**
+ * @see https://github.com/jsdom/jsdom/releases/tag/12.0.0
+ * @see https://github.com/jsdom/jsdom/issues/1537
+ */
+export declare const isJsDom: () => boolean;

package/helpers/enviroment.js

@@ -0,0 +1,20 @@
+"use strict";
+/* global window self */
+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
+ */
+/* 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

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

package/helpers/flattenCallsignsLookup.js

@@ -0,0 +1,10 @@
+"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.d.ts

@@ -0,0 +1 @@
+export declare const flattenObject: <T>(object: T) => T;

package/helpers/flattenObject.js

@@ -0,0 +1,17 @@
+"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') {
+                return _flatten(o[k]);
+            }
+            if (typeof o[k] === 'function') {
+                return false;
+            }
+            return { [k]: o[k] };
+        }));
+    })(object));
+};
+exports.flattenObject = flattenObject;

package/helpers/formatServiceUrl.d.ts

@@ -0,0 +1 @@
+export declare const formatServiceUrl: (url: string, params: Record<string, string>, insecure?: boolean) => string;

package/helpers/formatServiceUrl.js

@@ -0,0 +1,11 @@
+"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.d.ts

@@ -0,0 +1 @@
+export declare const generateUUID: () => string;

package/helpers/generateUUID.js

@@ -0,0 +1,8 @@
+"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

@@ -0,0 +1,10 @@
+declare type ISubscriptionsDifferenceRecord = {
+    callsigns: string[];
+    sources: any;
+};
+declare type ISubscriptionsDifference = {
+    toRemove: ISubscriptionsDifferenceRecord;
+    toAdd: ISubscriptionsDifferenceRecord;
+};
+export declare const getSubscriptionsDifference: (before: Record<string, string[]>, after: Record<string, string[]>) => ISubscriptionsDifference;
+export {};

package/helpers/getSubscriptionsDifference.js

@@ -0,0 +1,39 @@
+"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_1.arrayRemove(toRemove[key], after[key]);
+            if (!toRemove[key].length) {
+                delete toRemove[key];
+            }
+        }
+    });
+    Object.keys(after).forEach((key) => {
+        if (before[key]) {
+            toAdd[key] = arrayRemove_1.arrayRemove(toAdd[key], before[key]);
+            if (!toAdd[key].length) {
+                delete toAdd[key];
+            }
+        }
+    });
+    return {
+        toRemove: {
+            callsigns: Object.keys(toRemove),
+            sources: Object.values(toRemove).reduce((a, v) => {
+                return a.concat(v);
+            }, []),
+        },
+        toAdd: {
+            callsigns: Object.keys(toAdd),
+            sources: Object.values(toAdd).reduce((a, v) => {
+                return a.concat(v);
+            }, []),
+        },
+    };
+};
+exports.getSubscriptionsDifference = getSubscriptionsDifference;

package/helpers/getUniqueConfigKey.d.ts

@@ -0,0 +1,7 @@
+import { IRocosSDKConfig } from '../models/IRocosSDKConfig';
+/**
+ * Flattens and orders the sdk config props to make a unique key
+ *
+ * @param config - SDK config {@link IRocosSDKConfig}
+ */
+export declare const getUniqueConfigKey: (config: IRocosSDKConfig) => string;

package/helpers/getUniqueConfigKey.js

@@ -0,0 +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}
+ */
+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;