@dronedeploy/rocos-js-sdk 0.0.1 → 3.0.0-alpha.6

package/helpers/arrayRemove.d.ts

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

package/helpers/arrayRemove.js

@@ -0,0 +1,3 @@
+export const arrayRemove = (original, remove) => {
+    return original?.filter((v) => remove.indexOf(v) === -1);
+};

package/helpers/arrayUnique.d.ts

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

package/helpers/arrayUnique.js

@@ -0,0 +1,3 @@
+export const arrayUnique = (data) => {
+    return data?.filter((v, i, a) => a.indexOf(v) === i);
+};

package/helpers/average.d.ts

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

package/helpers/average.js

@@ -0,0 +1,6 @@
+export const average = (numbers) => {
+    const sum = numbers.reduce((numberSum, value) => {
+        return numberSum + value;
+    }, 0);
+    return sum / numbers.length;
+};

package/helpers/cleanObject.d.ts

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

package/helpers/cleanObject.js

@@ -0,0 +1,18 @@
+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),
+    };
+};

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.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,13 @@
+/* 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;
+/**
+ * @see https://github.com/jsdom/jsdom/releases/tag/12.0.0
+ * @see https://github.com/jsdom/jsdom/issues/1537
+ */
+export const isJsDom = () => {
+    return ((typeof window !== 'undefined' && window.name === 'nodejs') ||
+        navigator.userAgent.includes('Node.js') ||
+        navigator.userAgent.includes('jsdom'));
+};

package/helpers/flattenCallsignsLookup.d.ts

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

package/helpers/flattenCallsignsLookup.js

@@ -0,0 +1,6 @@
+export const flattenCallsignsLookup = (callsignsLookup) => {
+    if (callsignsLookup.lookupValue) {
+        return callsignsLookup.toID();
+    }
+    return callsignsLookup.sort();
+};

package/helpers/flattenObject.d.ts

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

package/helpers/flattenObject.js

@@ -0,0 +1,13 @@
+export 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));
+};

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.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,7 @@
+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;
+};

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.d.ts

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

package/helpers/generateUUID.js

@@ -0,0 +1,4 @@
+import { v4 as uuidv4 } from 'uuid';
+export const generateUUID = () => {
+    return uuidv4();
+};

package/helpers/getSubscriptionsDifference.d.ts

@@ -0,0 +1,10 @@
+type ISubscriptionsDifferenceRecord = {
+    callsigns: string[];
+    sources: string[];
+};
+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,35 @@
+import { arrayRemove } from './arrayRemove';
+export const getSubscriptionsDifference = (before, after) => {
+    const toRemove = { ...before };
+    const toAdd = { ...after };
+    Object.keys(before).forEach((key) => {
+        if (after[key]) {
+            toRemove[key] = arrayRemove(toRemove[key], after[key]);
+            if (!toRemove[key].length) {
+                delete toRemove[key];
+            }
+        }
+    });
+    Object.keys(after).forEach((key) => {
+        if (before[key]) {
+            toAdd[key] = 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);
+            }, []),
+        },
+    };
+};

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,14 @@
+/**
+ * Flattens and orders the sdk config props to make a unique key
+ *
+ * @param config - SDK config {@link IRocosSDKConfig}
+ */
+export const getUniqueConfigKey = (config) => {
+    return Object.keys(config)
+        .sort()
+        .map((item) => {
+        return item !== 'token' ? `${item}:${config[item]}` : false;
+    })
+        .filter(Boolean)
+        .join();
+};

package/helpers/getUniqueId.d.ts

@@ -0,0 +1,9 @@
+import { CallsignsLookup } from '../models/callsigns/CallsignsLookup';
+/**
+ *
+ * @param projectId
+ * @param callsignsLookup = CallsignsLookup or String[] for backward compatibility for the portal using callsigns string array
+ * @param sources
+ * @param scope
+ */
+export declare const getUniqueId: (projectId: string, callsignsLookup: CallsignsLookup | string[], sources: string[], scope: string) => string;

package/helpers/getUniqueId.js

@@ -0,0 +1,11 @@
+import { flattenCallsignsLookup } from './flattenCallsignsLookup';
+/**
+ *
+ * @param projectId
+ * @param callsignsLookup = CallsignsLookup or String[] for backward compatibility for the portal using callsigns string array
+ * @param sources
+ * @param scope
+ */
+export const getUniqueId = (projectId, callsignsLookup, sources, scope) => {
+    return [projectId, ...flattenCallsignsLookup(callsignsLookup), ...sources.sort(), scope].join();
+};

package/helpers/getUnixTimeMs.d.ts

@@ -0,0 +1 @@
+export declare const getUnixTimeMs: (offsetMs: number, baseOn?: Date) => number;

package/helpers/getUnixTimeMs.js

@@ -0,0 +1,4 @@
+export const getUnixTimeMs = (offsetMs, baseOn = new Date()) => {
+    const newDate = new Date(baseOn.getTime() + offsetMs);
+    return newDate.getTime(); // Convert date to ms.
+};

package/helpers/index.d.ts

@@ -0,0 +1,3 @@
+export * from './average';
+export * from './standardDeviation';
+export * from './generateUUID';

package/helpers/index.js

@@ -0,0 +1,3 @@
+export * from './average';
+export * from './standardDeviation';
+export * from './generateUUID';

package/helpers/nanosecondToMillisecond.d.ts

@@ -0,0 +1 @@
+export declare const nanosecondToMillisecond: (nano: number | string) => number;

package/helpers/nanosecondToMillisecond.js

@@ -0,0 +1,12 @@
+function isNumber(n) {
+    return typeof n === 'number';
+}
+export const nanosecondToMillisecond = (nano) => {
+    if (isNumber(nano)) {
+        return nano / 1e6;
+    }
+    if (nano.length < 16) {
+        return Number(nano) / 1e6;
+    }
+    return Number(nano.slice(0, -6) + '.' + nano.slice(-6));
+};

package/helpers/nanosecondToMillisecond.spec.d.ts

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

package/helpers/nanosecondToMillisecond.spec.js

@@ -0,0 +1,20 @@
+import { nanosecondToMillisecond } from './nanosecondToMillisecond';
+describe('nanosecondToMillisecond', () => {
+    it.each `
+    input                    | expected
+    ${'0.0001'}              | ${0.0000000001}
+    ${'1'}                   | ${0.000001}
+    ${'1000000'}             | ${1}
+    ${'10000000'}            | ${10}
+    ${'-100000006'}           | ${-100.000006}
+    ${'1000000000000000000'} | ${1000000000000}
+    ${'1234567891011100001'} | ${1234567891011.100001}
+    ${'1234567891011100000'} | ${1234567891011.1}
+    ${0.0001}                | ${0.0000000001}
+    ${1}                     | ${0.000001}
+    ${1000000}               | ${1}
+    ${1000000000000001}      | ${1000000000.000001}
+  `('should convert $input to $expected', ({ input, expected }) => {
+        expect(nanosecondToMillisecond(input)).toBe(expected);
+    });
+});

package/helpers/randomString.d.ts

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