@dronedeploy/rocos-js-sdk 2.6.1 → 3.0.0-alpha.20

package/helpers/arrayRemove.js

@@ -1,7 +1,3 @@
-"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);
+export const arrayRemove = (original, remove) => {
+    return original?.filter((v) => remove.indexOf(v) === -1);
 };
-exports.arrayRemove = arrayRemove;

package/helpers/arrayUnique.js

@@ -1,7 +1,3 @@
-"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);
+export const arrayUnique = (data) => {
+    return data?.filter((v, i, a) => a.indexOf(v) === i);
 };
-exports.arrayUnique = arrayUnique;

package/helpers/average.js

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

package/helpers/callerMessageHelpers.d.ts

@@ -0,0 +1,14 @@
+import { IRocosCallerMessage, IRocosCallerMessageChunk, IRocosCallerMessageResponse } from '../models';
+import { OperatorFunction } from 'rxjs';
+/** Given a caller message, return the responses contained within it.
+ *
+ * Chunked responses with acks and results will return the intermediate acks and results as Responses along with the chunk itself
+ */
+export declare function getResponses(res: IRocosCallerMessage): (IRocosCallerMessageResponse | IRocosCallerMessageChunk)[];
+/** A pipeable operator that will convert a stream of chunks into a stream of responses.
+ *
+ * Any non-chunk messages will be passed through unchanged.
+ *
+ * Chunked responses will be buffered until all chunks are received, then merged into a single response.
+ */
+export declare function handleChunkedMessages(): OperatorFunction<IRocosCallerMessageChunk | IRocosCallerMessageResponse, IRocosCallerMessageResponse>;

package/helpers/callerMessageHelpers.js

@@ -0,0 +1,86 @@
+import { map, pipe } from 'rxjs';
+import { filter } from 'rxjs/operators';
+/** Given a caller message, return the responses contained within it.
+ *
+ * Chunked responses with acks and results will return the intermediate acks and results as Responses along with the chunk itself
+ */
+export function getResponses(res) {
+    if (res.chunks?.chunks) {
+        return getIntermediateResponsesFromChunks(res.chunks.chunks);
+    }
+    if (res.responses?.responses) {
+        return res.responses.responses;
+    }
+    return [];
+}
+/** Given a list of chunks, convert any intermediate acks and results into responses. */
+function getIntermediateResponsesFromChunks(chunks) {
+    const responses = [];
+    for (const chunk of chunks) {
+        // chunk needs to be pushed first so that the final response can be constructed from the chunks
+        // before any result message can close the observable
+        responses.push(chunk);
+        if (chunk.uid && (chunk.ack || chunk.result)) {
+            responses.push({
+                uid: chunk.uid,
+                ack: chunk.ack,
+                result: chunk.result,
+            });
+        }
+    }
+    return responses;
+}
+/** A pipeable operator that will convert a stream of chunks into a stream of responses.
+ *
+ * Any non-chunk messages will be passed through unchanged.
+ *
+ * Chunked responses will be buffered until all chunks are received, then merged into a single response.
+ */
+export function handleChunkedMessages() {
+    let chunkBuffer = null;
+    return pipe(map((message) => {
+        if ('chunkIndex' in message) {
+            if (chunkBuffer === null) {
+                chunkBuffer = new Array(message.chunkCount);
+            }
+            chunkBuffer[message.chunkIndex] = message;
+            // have to check with Object.keys because the array is buffered and the length is not accurate
+            if (Object.keys(chunkBuffer).length !== message.chunkCount) {
+                return;
+            }
+            return buildResponseFromChunks(chunkBuffer);
+        }
+        return message;
+    }), filter(Boolean));
+}
+/** Given a complete set of chunks, build a single response. */
+function buildResponseFromChunks(chunks) {
+    const chunkPayloads = chunks.map((x) => x.payload).filter((x) => x !== undefined);
+    const payloadLength = chunkPayloads.reduce((acc, x) => acc + x.length, 0);
+    const mergedPayload = new Uint8Array(payloadLength);
+    for (let i = 0, offset = 0; i < chunkPayloads.length; i++) {
+        mergedPayload.set(chunkPayloads[i], offset);
+        offset += chunkPayloads[i].length;
+    }
+    const [header] = chunks.map((x) => x.header).filter((x) => x !== undefined);
+    if (header === undefined || Array.isArray(header)) {
+        throw new Error('No header found in chunks');
+    }
+    const [uid] = chunks.map((x) => x.uid).filter((x) => x !== undefined);
+    if (uid === undefined || Array.isArray(uid)) {
+        throw new Error('No uid found in chunks');
+    }
+    const createdAt = new Date(Number(header.created) * 1000);
+    const createdNs = (BigInt(header.created) * BigInt(1e9)).toString();
+    return {
+        uid,
+        return: {
+            header: {
+                createdNs,
+                createdAt,
+                meta: header.meta,
+            },
+            payload: mergedPayload,
+        },
+    };
+}

package/helpers/cleanObject.js

@@ -1,20 +1,18 @@
-"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));
+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),
+    };
 };
-exports.cleanObject = cleanObject;

package/helpers/cleanObject.spec.d.ts

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

package/helpers/cleanObject.spec.js

@@ -0,0 +1,53 @@
+import { cleanObject } from "./cleanObject";
+describe('cleanObject', () => {
+    const testObject = {
+        test1: 'test1',
+        test2: 'test2',
+        test3: () => 'test3',
+        test4: {
+            test1: 'test1.1',
+            test5: 'test5',
+            test6: {
+                test7: 'test7',
+                test1: 'test1.2',
+                test2: 'test2.1',
+                test8: () => 'test8',
+            },
+            test8: () => 'test8',
+        },
+        test9: ['test9.1', 'test9.2', () => 'test8'],
+        test10: [
+            {
+                test7: 'test7',
+                test1: 'test1.2',
+                test2: 'test2.1',
+                test8: () => 'test8',
+            },
+            {
+                test8: () => 'test8',
+            },
+        ],
+    };
+    it('should clean object to values only', () => {
+        const newObject = cleanObject(testObject);
+        expect(newObject?.test3).toBeUndefined();
+        expect(newObject?.test4?.test8).toBeUndefined();
+        expect(newObject?.test4?.test6?.test8).toBeUndefined();
+        expect(newObject?.test4?.test5).toEqual('test5');
+        expect(newObject?.test5).toBeUndefined();
+        expect(newObject?.test4?.test6?.test1).toEqual('test1.2');
+        expect(newObject?.test4?.test6?.test2).toEqual('test2.1');
+        expect(newObject?.test1).toEqual('test1');
+        expect(newObject?.test2).toEqual('test2');
+        expect(newObject?.test9).toEqual(expect.arrayContaining(['test9.1', 'test9.2']));
+        expect(newObject?.test9).toEqual(expect.not.arrayContaining([() => 'test8']));
+        expect(newObject?.test10).toEqual(expect.arrayContaining([
+            {
+                test7: 'test7',
+                test1: 'test1.2',
+                test2: 'test2.1',
+            },
+            {},
+        ]));
+    });
+});

package/helpers/enviroment.js

@@ -1,20 +1,13 @@
-"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;
+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;
 /**
  * @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 = () => {
+export 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/callsigns/CallsignsLookup';
+import { CallsignsLookup } from '../models';
 export declare const flattenCallsignsLookup: (callsignsLookup: CallsignsLookup | string[]) => string[];

package/helpers/flattenCallsignsLookup.js

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

package/helpers/flattenObject.js

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

package/helpers/flattenObject.spec.d.ts

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

package/helpers/flattenObject.spec.js

@@ -0,0 +1,29 @@
+import { flattenObject } from './flattenObject';
+describe('flattenObject', () => {
+    const testObject = {
+        test1: 'test1',
+        test2: 'test2',
+        test3: () => 'test3',
+        test4: {
+            test1: 'test1.1',
+            test5: 'test5',
+            test6: {
+                test7: 'test7',
+                test1: 'test1.2',
+                test2: 'test2.1',
+                test8: () => 'test8',
+            },
+            test8: () => 'test8',
+        },
+    };
+    it('should flatten object to a single level', () => {
+        const newObject = flattenObject(testObject);
+        expect(newObject?.test3).toBeUndefined();
+        expect(newObject?.test4?.test8).toBeUndefined();
+        expect(newObject?.test4?.test6?.test8).toBeUndefined();
+        expect(newObject?.test4?.test5).toBeUndefined();
+        expect(newObject?.test5).toEqual('test5');
+        expect(newObject?.test1).toEqual('test1.2');
+        expect(newObject?.test2).toEqual('test2.1');
+    });
+});

package/helpers/flattenOneOf.d.ts

@@ -0,0 +1,67 @@
+type Intersect<T> = (T extends any ? (x: T) => 0 : never) extends (x: infer R) => 0 ? R : never;
+type DropKey<T, K extends keyof T> = {
+    [P in keyof T as P extends K ? never : P]: T[P];
+};
+type WrapTypes<T> = {
+    [K in keyof T]: T[K] extends (...args: any[]) => any ? T[K] : DeepFlattenedOneOf<T[K]>;
+};
+interface OneOfProperty {
+    content: {
+        oneofKind?: string;
+        [key: string]: unknown;
+    };
+}
+/**
+ * This is a helper type to flatten oneOf types in the generated protobuf.
+ *
+ * @example
+ * type T = { a: string; content: { oneofKind: 'b'; b: boolean } | { oneofKind: 'c'; c: number } }
+ * FlattenedOneOf<T> === { a: string; b?: boolean; c?: number }`
+ */
+type FlattenedOneOf<Original> = Original extends OneOfProperty ? Omit<Original, 'content'> & Partial<Intersect<DropKey<Original['content'], 'oneofKind'>>> : Original;
+/**
+ * This is a helper type to recursively flatten oneOf types in the generated protobuf.
+ *
+ * @example
+ * type T = { a: string; content: { oneofKind: 'b'; b: {content: {oneofKind: 'b1', b1: string}} } | { oneofKind: 'c'; c: number } }
+ * DeepFlattenedOneOf<T> === { a: string; b?: {b1?: string}; c?: number }`
+ */
+type DeepFlattenedOneOf<Original> = WrapTypes<FlattenedOneOf<Original>>;
+export declare function hasOneOfField(object: unknown): object is OneOfProperty;
+/**
+ * This function flattens oneOf types in the generated protobuf.
+ *
+ * @example
+ * const a = { a: 'a', content: { oneofKind: 'b', b: true } }
+ * flattenOneOf(a) === { a: 'a', b: true }
+ *
+ * @param object the object to flatten
+ * @param deep whether to recursively flatten oneOf types
+ */
+export declare function flattenOneOf<T>(object: T, deep?: false): FlattenedOneOf<T>;
+/**
+ * This function flattens oneOf types in the generated protobuf.
+ *
+ * @example
+ * const a = {
+ *   b: {
+ *     content: { oneofKind: 'c', c: true },
+ *   },
+ *   content: {
+ *     oneofKind: 'd',
+ *     d: {
+ *       content: {
+ *         oneofKind: 'e',
+ *         e: 5,
+ *       },
+ *     },
+ *   },
+ * }
+ *
+ * flattenOneOf(a, true) === {b: {c: true}, d: {e: 5}}
+ *
+ * @param object the object to flatten
+ * @param deep whether to recursively flatten oneOf types
+ */
+export declare function flattenOneOf<T>(object: T, deep: true): DeepFlattenedOneOf<T>;
+export {};

package/helpers/flattenOneOf.js

@@ -0,0 +1,29 @@
+export function hasOneOfField(object) {
+    if (typeof object !== 'object' || object === null)
+        return false;
+    if (!('content' in object) || object.content === null || typeof object.content !== 'object') {
+        return false;
+    }
+    return 'oneofKind' in object.content && typeof object.content.oneofKind === 'string';
+}
+export function flattenOneOf(object, deep = false) {
+    const newObject = { ...object };
+    const inner = (obj) => {
+        let newKey;
+        if (hasOneOfField(obj)) {
+            newKey = obj.content.oneofKind;
+            if (newKey)
+                obj[newKey] = obj.content[newKey];
+            delete obj.content;
+        }
+        if (deep) {
+            for (const value of Object.values(obj)) {
+                if (value === null || typeof value !== 'object')
+                    continue;
+                inner(value);
+            }
+        }
+        return obj;
+    };
+    return inner(newObject);
+}

package/helpers/flattenOneOf.spec.d.ts

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

package/helpers/flattenOneOf.spec.js

@@ -0,0 +1,157 @@
+import { flattenOneOf, hasOneOfField } from './flattenOneOf';
+describe('flattenOneOf', () => {
+    describe('hasOneOfField', () => {
+        it('should return false for non-object', () => {
+            expect(hasOneOfField(null)).toBe(false);
+            expect(hasOneOfField(undefined)).toBe(false);
+            expect(hasOneOfField(1)).toBe(false);
+            expect(hasOneOfField('')).toBe(false);
+            expect(hasOneOfField(true)).toBe(false);
+        });
+        it('should return false for null content', () => {
+            expect(hasOneOfField({ content: null })).toBe(false);
+        });
+        it('should return false for non-object content', () => {
+            expect(hasOneOfField({ content: 1 })).toBe(false);
+            expect(hasOneOfField({ content: '' })).toBe(false);
+            expect(hasOneOfField({ content: true })).toBe(false);
+        });
+        it('should return false for non-string oneofKind', () => {
+            expect(hasOneOfField({ content: { oneofKind: 1 } })).toBe(false);
+            expect(hasOneOfField({ content: { oneofKind: null } })).toBe(false);
+            expect(hasOneOfField({ content: { oneofKind: true } })).toBe(false);
+            expect(hasOneOfField({ content: { oneofKind: {} } })).toBe(false);
+        });
+        it('should return true for valid oneOfField', () => {
+            expect(hasOneOfField({ content: { oneofKind: 'test' } })).toBe(true);
+        });
+    });
+    describe('flattenOneOf', () => {
+        it('should flatten a simple oneof type', () => {
+            const a = {
+                a: 'a',
+                content: {
+                    oneofKind: 'b',
+                    b: true,
+                },
+            };
+            expect(flattenOneOf(a)).toEqual({
+                a: 'a',
+                b: true,
+            });
+        });
+        it('should flatten a nested oneof type, one level only', () => {
+            const a = {
+                b: {
+                    content: {
+                        oneofKind: 'c',
+                        c: true,
+                    },
+                },
+                content: {
+                    oneofKind: 'd',
+                    d: {
+                        content: {
+                            oneofKind: 'e',
+                            e: 5,
+                        },
+                    },
+                },
+            };
+            expect(flattenOneOf(a)).toEqual({
+                b: {
+                    content: {
+                        oneofKind: 'c',
+                        c: true,
+                    },
+                },
+                d: {
+                    content: {
+                        oneofKind: 'e',
+                        e: 5,
+                    },
+                },
+            });
+        });
+        it('should flatten to undefined if the referenced property does not exist', () => {
+            const a = {
+                content: {
+                    oneofKind: 'b',
+                    c: true,
+                },
+            };
+            expect(flattenOneOf(a)).toEqual({
+                b: undefined,
+            });
+        });
+        it('should return the original object if it does not have a oneof field', () => {
+            const a = {
+                a: 'a',
+                b: 'b',
+            };
+            expect(flattenOneOf(a)).toEqual(a);
+        });
+    });
+    describe('flattenOneOf - deep', () => {
+        it('should flatten a simple oneof type', () => {
+            const a = {
+                a: 'a',
+                content: {
+                    oneofKind: 'b',
+                    b: {
+                        d: 4,
+                    },
+                },
+            };
+            expect(flattenOneOf(a, true)).toEqual({
+                a: 'a',
+                b: { d: 4 },
+            });
+        });
+        it('should flatten a nested oneof type, all levels', () => {
+            const a = {
+                b: {
+                    content: {
+                        oneofKind: 'c',
+                        c: true,
+                    },
+                },
+                content: {
+                    oneofKind: 'd',
+                    d: {
+                        content: {
+                            oneofKind: 'e',
+                            e: 5,
+                        },
+                    },
+                },
+            };
+            expect(flattenOneOf(a, true)).toEqual({
+                b: {
+                    c: true,
+                },
+                d: {
+                    e: 5,
+                },
+            });
+        });
+        it('should flatten to undefined if the referenced property does not exist', () => {
+            const a = {
+                content: {
+                    oneofKind: 'b',
+                    c: true,
+                },
+            };
+            expect(flattenOneOf(a, true)).toEqual({
+                b: undefined,
+            });
+        });
+        it('should return the original object if it does not have a oneof field', () => {
+            const a = {
+                a: 'a',
+                b: 'b',
+            };
+            expect(flattenOneOf(a, true)).toEqual(a);
+        });
+    });
+});

package/helpers/formatServiceUrl.js

@@ -1,11 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.formatServiceUrl = void 0;
-const formatServiceUrl = (url, params, insecure = false) => {
+export 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/formatServiceUrl.spec.d.ts

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

package/helpers/formatServiceUrl.spec.js

@@ -0,0 +1,16 @@
+import { formatServiceUrl } from './formatServiceUrl';
+describe('formatServiceUrl', () => {
+    const url = 'https://{url}/admin/users/{test}/invitations';
+    it('should format url', () => {
+        let newUrl = formatServiceUrl(url, { url: 'test.com', test: 'me' });
+        expect(newUrl).toEqual('https://test.com/admin/users/me/invitations');
+        newUrl = formatServiceUrl(url, { url: 'test2.com', test: 'me2' });
+        expect(newUrl).toEqual('https://test2.com/admin/users/me2/invitations');
+    });
+    it('should format insecure url', () => {
+        let newUrl = formatServiceUrl(url, { url: 'test.com', test: 'me' }, true);
+        expect(newUrl).toEqual('http://test.com/admin/users/me/invitations');
+        newUrl = formatServiceUrl(url, { url: 'test2.com', test: 'me2' }, true);
+        expect(newUrl).toEqual('http://test2.com/admin/users/me2/invitations');
+    });
+});

package/helpers/generateUUID.js

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

package/helpers/getSubscriptionsDifference.d.ts

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