@dronedeploy/rocos-js-sdk 3.0.1-alpha → 3.0.1-alpha.11

package/cjs/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?.filter((v) => remove.indexOf(v) === -1);
+};
+exports.arrayRemove = arrayRemove;

package/cjs/helpers/arrayUnique.js

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

package/cjs/helpers/average.js

@@ -0,0 +1,10 @@
+"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;
+};
+exports.average = average;

package/cjs/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/cjs/helpers/callerMessageHelpers.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleChunkedMessages = exports.getResponses = void 0;
+const rxjs_1 = require("rxjs");
+const operators_1 = require("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
+ */
+function getResponses(res) {
+    if (res.chunks?.chunks) {
+        return getIntermediateResponsesFromChunks(res.chunks.chunks);
+    }
+    if (res.responses?.responses) {
+        return res.responses.responses;
+    }
+    return [];
+}
+exports.getResponses = getResponses;
+/** 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.
+ */
+function handleChunkedMessages() {
+    let chunkBuffer = null;
+    return (0, rxjs_1.pipe)((0, rxjs_1.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;
+    }), (0, operators_1.filter)(Boolean));
+}
+exports.handleChunkedMessages = handleChunkedMessages;
+/** 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/cjs/helpers/cleanObject.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cleanObject = void 0;
+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/cjs/helpers/cleanObject.spec.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const cleanObject_1 = require("./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 = (0, cleanObject_1.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/cjs/helpers/enviroment.js

@@ -0,0 +1,17 @@
+"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';
+exports.isWebWorker = typeof self === 'object' && self.constructor && self.constructor.name === 'DedicatedWorkerGlobalScope';
+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
+ */
+const isJsDom = () => {
+    return ((typeof window !== 'undefined' && window.name === 'nodejs') ||
+        navigator.userAgent.includes('Node.js') ||
+        navigator.userAgent.includes('jsdom'));
+};
+exports.isJsDom = isJsDom;

package/cjs/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/cjs/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/cjs/helpers/flattenObject.spec.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const flattenObject_1 = require("./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 = (0, flattenObject_1.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/cjs/helpers/flattenOneOf.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.flattenOneOf = exports.hasOneOfField = void 0;
+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';
+}
+exports.hasOneOfField = hasOneOfField;
+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);
+}
+exports.flattenOneOf = flattenOneOf;

package/cjs/helpers/flattenOneOf.spec.js

@@ -0,0 +1,159 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const flattenOneOf_1 = require("./flattenOneOf");
+describe('flattenOneOf', () => {
+    describe('hasOneOfField', () => {
+        it('should return false for non-object', () => {
+            expect((0, flattenOneOf_1.hasOneOfField)(null)).toBe(false);
+            expect((0, flattenOneOf_1.hasOneOfField)(undefined)).toBe(false);
+            expect((0, flattenOneOf_1.hasOneOfField)(1)).toBe(false);
+            expect((0, flattenOneOf_1.hasOneOfField)('')).toBe(false);
+            expect((0, flattenOneOf_1.hasOneOfField)(true)).toBe(false);
+        });
+        it('should return false for null content', () => {
+            expect((0, flattenOneOf_1.hasOneOfField)({ content: null })).toBe(false);
+        });
+        it('should return false for non-object content', () => {
+            expect((0, flattenOneOf_1.hasOneOfField)({ content: 1 })).toBe(false);
+            expect((0, flattenOneOf_1.hasOneOfField)({ content: '' })).toBe(false);
+            expect((0, flattenOneOf_1.hasOneOfField)({ content: true })).toBe(false);
+        });
+        it('should return false for non-string oneofKind', () => {
+            expect((0, flattenOneOf_1.hasOneOfField)({ content: { oneofKind: 1 } })).toBe(false);
+            expect((0, flattenOneOf_1.hasOneOfField)({ content: { oneofKind: null } })).toBe(false);
+            expect((0, flattenOneOf_1.hasOneOfField)({ content: { oneofKind: true } })).toBe(false);
+            expect((0, flattenOneOf_1.hasOneOfField)({ content: { oneofKind: {} } })).toBe(false);
+        });
+        it('should return true for valid oneOfField', () => {
+            expect((0, flattenOneOf_1.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((0, flattenOneOf_1.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((0, flattenOneOf_1.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((0, flattenOneOf_1.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((0, flattenOneOf_1.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((0, flattenOneOf_1.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((0, flattenOneOf_1.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((0, flattenOneOf_1.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((0, flattenOneOf_1.flattenOneOf)(a, true)).toEqual(a);
+        });
+    });
+});

package/cjs/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/cjs/helpers/formatServiceUrl.spec.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const formatServiceUrl_1 = require("./formatServiceUrl");
+describe('formatServiceUrl', () => {
+    const url = 'https://{url}/admin/users/{test}/invitations';
+    it('should format url', () => {
+        let newUrl = (0, formatServiceUrl_1.formatServiceUrl)(url, { url: 'test.com', test: 'me' });
+        expect(newUrl).toEqual('https://test.com/admin/users/me/invitations');
+        newUrl = (0, formatServiceUrl_1.formatServiceUrl)(url, { url: 'test2.com', test: 'me2' });
+        expect(newUrl).toEqual('https://test2.com/admin/users/me2/invitations');
+    });
+    it('should format insecure url', () => {
+        let newUrl = (0, formatServiceUrl_1.formatServiceUrl)(url, { url: 'test.com', test: 'me' }, true);
+        expect(newUrl).toEqual('http://test.com/admin/users/me/invitations');
+        newUrl = (0, formatServiceUrl_1.formatServiceUrl)(url, { url: 'test2.com', test: 'me2' }, true);
+        expect(newUrl).toEqual('http://test2.com/admin/users/me2/invitations');
+    });
+});

package/cjs/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 (0, uuid_1.v4)();
+};
+exports.generateUUID = generateUUID;

package/cjs/helpers/getSha256Hex.d.ts

@@ -0,0 +1 @@
+export declare const getSha256Hex: (arrayBuffer: ArrayBuffer) => Promise<string>;

package/cjs/helpers/getSha256Hex.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSha256Hex = void 0;
+const getSha256Hex = async (arrayBuffer) => {
+    const hashBuffer = await crypto.subtle.digest('SHA-256', arrayBuffer);
+    const hashArray = Array.from(new Uint8Array(hashBuffer));
+    return hashArray.map((b) => b.toString(16).padStart(2, '0')).join('');
+};
+exports.getSha256Hex = getSha256Hex;

package/cjs/helpers/getSha256Hex.spec.js

@@ -0,0 +1,19 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const crypto_1 = __importDefault(require("crypto"));
+const getSha256Hex_1 = require("./getSha256Hex");
+Object.defineProperty(globalThis, 'crypto', {
+    value: {
+        subtle: crypto_1.default.webcrypto.subtle,
+    },
+});
+describe('getSha256Hex', () => {
+    it('should return the correct SHA-256 hash', async () => {
+        const buffer = new TextEncoder().encode('Hello, World!');
+        const hash = await (0, getSha256Hex_1.getSha256Hex)(buffer);
+        expect(hash).toBe('dffd6021bb2bd5b0af676290809ec3a53191dd81c7f70a4b28688a362182986f');
+    });
+});

package/cjs/helpers/getSha256HexNode.d.ts

@@ -0,0 +1 @@
+export declare const getSha256HexNode: (arrayBuffer: ArrayBuffer) => Promise<string>;

package/cjs/helpers/getSha256HexNode.js

@@ -0,0 +1,13 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSha256HexNode = void 0;
+const crypto_1 = __importDefault(require("crypto"));
+const getSha256HexNode = async (arrayBuffer) => {
+    const hashBuffer = await crypto_1.default.subtle.digest('SHA-256', arrayBuffer);
+    const hashArray = Array.from(new Uint8Array(hashBuffer));
+    return hashArray.map((b) => b.toString(16).padStart(2, '0')).join('');
+};
+exports.getSha256HexNode = getSha256HexNode;

package/cjs/helpers/getSha256HexNode.spec.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const getSha256HexNode_1 = require("./getSha256HexNode");
+describe('getSha256HexNode', () => {
+    it('should return the correct SHA-256 hash', async () => {
+        const buffer = new TextEncoder().encode('Hello, World!');
+        const hash = await (0, getSha256HexNode_1.getSha256HexNode)(buffer);
+        expect(hash).toBe('dffd6021bb2bd5b0af676290809ec3a53191dd81c7f70a4b28688a362182986f');
+    });
+});

package/cjs/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 = { ...before };
+    const toAdd = { ...after };
+    Object.keys(before).forEach((key) => {
+        if (after[key]) {
+            toRemove[key] = (0, arrayRemove_1.arrayRemove)(toRemove[key], after[key]);
+            if (!toRemove[key].length) {
+                delete toRemove[key];
+            }
+        }
+    });
+    Object.keys(after).forEach((key) => {
+        if (before[key]) {
+            toAdd[key] = (0, 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/cjs/helpers/getURLSearchParams.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getURLSearchParams = void 0;
+const getURLSearchParams = (params) => {
+    if (params instanceof URLSearchParams)
+        return params;
+    const stringParams = Object.entries(params ?? {}).reduce((acc, [key, value]) => {
+        acc[key] = value.toString();
+        return acc;
+    }, {});
+    return new URLSearchParams(stringParams);
+};
+exports.getURLSearchParams = getURLSearchParams;