@dronedeploy/rocos-js-sdk 3.0.1-alpha.3 → 3.0.1-alpha.31

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,25 @@
+"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 (val === null) {
+                    obj[key] = val;
+                }
+                else 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/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/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/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/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/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/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;

package/cjs/helpers/getUniqueConfigKey.d.ts

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

package/cjs/helpers/getUniqueConfigKey.js

@@ -0,0 +1,23 @@
+"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) => {
+    let rootConfig = config;
+    if (rootConfig._parentConfig) {
+        // assume there is only one level of nesting
+        rootConfig = rootConfig._parentConfig;
+    }
+    return Object.keys(rootConfig)
+        .sort()
+        .map((item) => {
+        return item !== 'token' ? `${item}:${rootConfig[item]}` : false;
+    })
+        .filter(Boolean)
+        .join();
+};
+exports.getUniqueConfigKey = getUniqueConfigKey;

package/cjs/helpers/getUniqueId.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getUniqueId = void 0;
+const flattenCallsignsLookup_1 = require("./flattenCallsignsLookup");
+/**
+ *
+ * @param projectId
+ * @param callsignsLookup = CallsignsLookup or String[] for backward compatibility for the portal using callsigns string array
+ * @param sources
+ * @param scope
+ */
+const getUniqueId = (projectId, callsignsLookup, sources, scope) => {
+    return [projectId, ...(0, flattenCallsignsLookup_1.flattenCallsignsLookup)(callsignsLookup), ...sources.sort(), scope].join();
+};
+exports.getUniqueId = getUniqueId;

package/cjs/helpers/getUnixTimeMs.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getUnixTimeMs = void 0;
+const getUnixTimeMs = (offsetMs, baseOn = new Date()) => {
+    const newDate = new Date(baseOn.getTime() + offsetMs);
+    return newDate.getTime(); // Convert date to ms.
+};
+exports.getUnixTimeMs = getUnixTimeMs;

package/cjs/helpers/index.d.ts

@@ -0,0 +1,6 @@
+export * from './average';
+export * from './standardDeviation';
+export * from './generateUUID';
+export * from './getURLSearchParams';
+export * from './websandbox';
+export * from './kscript';

package/cjs/helpers/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./average"), exports);
+__exportStar(require("./standardDeviation"), exports);
+__exportStar(require("./generateUUID"), exports);
+__exportStar(require("./getURLSearchParams"), exports);
+__exportStar(require("./websandbox"), exports);
+__exportStar(require("./kscript"), exports);

package/cjs/helpers/kscript/Context.d.ts

@@ -0,0 +1,34 @@
+import { AnyNode } from 'acorn';
+import type { NodeType } from './nodes';
+/**
+ * A map of node types to a set of property names that are allowed to be accessed
+ * on the prototype of the object.
+ *
+ * If the set is null, all properties are allowed.
+ */
+export type PrototypeWhitelist = Map<unknown, Set<string> | null>;
+export type Scope = Map<string, unknown> | Record<string, unknown>;
+export interface ContextOptions {
+    nodeBlacklist?: Set<NodeType>;
+    prototypeWhitelist?: PrototypeWhitelist;
+    functionCallsAllowed?: boolean;
+}
+export default class Context {
+    readonly scope: Map<string, unknown>;
+    readonly isFunctionCallAllowed: boolean;
+    private readonly options;
+    constructor(scope?: Scope, options?: ContextOptions);
+    isNodeAllowed(nodeType: AnyNode['type']): boolean;
+    newChildContext(scope: Scope): Context;
+    /** Returns true if the property is allowed to be accessed on the prototype.
+     *
+     * - If the prototype is not in the whitelist, the property is allowed only if it is an own property.
+     * - If the prototype is in the whitelist, the property is allowed if it is in the set or the set is null.
+     *
+     * @param prototype The prototype which contains the property being accessed.
+     * @param property The name of the property being accessed.
+     * @param ownProperty Whether the property is owned by the object it is being accessed on.
+     */
+    isPrototypeAllowed(prototype: unknown, property: string, ownProperty: boolean): boolean;
+    private static buildMap;
+}

package/cjs/helpers/kscript/Context.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class Context {
+    constructor(scope, options) {
+        this.scope = scope ? Context.buildMap(scope) : new Map();
+        this.options = {
+            nodeBlacklist: options?.nodeBlacklist ?? new Set(),
+            prototypeWhitelist: options?.prototypeWhitelist ?? new Map(),
+            functionCallsAllowed: options?.functionCallsAllowed ?? true,
+        };
+        this.isFunctionCallAllowed = this.options.functionCallsAllowed;
+    }
+    isNodeAllowed(nodeType) {
+        return !this.options.nodeBlacklist.has(nodeType);
+    }
+    newChildContext(scope) {
+        let newEntries;
+        if (scope instanceof Map) {
+            newEntries = [...scope.entries()];
+        }
+        else {
+            newEntries = Object.entries(scope);
+        }
+        const newScope = new Map([...this.scope.entries(), ...newEntries]);
+        return new Context(newScope, this.options);
+    }
+    /** Returns true if the property is allowed to be accessed on the prototype.
+     *
+     * - If the prototype is not in the whitelist, the property is allowed only if it is an own property.
+     * - If the prototype is in the whitelist, the property is allowed if it is in the set or the set is null.
+     *
+     * @param prototype The prototype which contains the property being accessed.
+     * @param property The name of the property being accessed.
+     * @param ownProperty Whether the property is owned by the object it is being accessed on.
+     */
+    isPrototypeAllowed(prototype, property, ownProperty) {
+        const whitelist = this.options.prototypeWhitelist.get(prototype);
+        // If the object owns the property, and it's not in the whitelist, it's allowed.
+        // This prevents direct calls to non-whitelisted properties on allowed prototypes
+        // e.g. Object.prototype.hasOwnProperty.call(obj, 'toString')
+        if (whitelist === undefined)
+            return ownProperty;
+        // all properties allowed if no set is provided
+        if (whitelist === null)
+            return true;
+        return whitelist.has(property);
+    }
+    static buildMap(obj) {
+        return obj instanceof Map ? obj : new Map(Object.entries(obj));
+    }
+}
+exports.default = Context;

package/cjs/helpers/kscript/index.d.ts

@@ -0,0 +1 @@
+export * as kscript from './kscript';

package/cjs/helpers/kscript/index.js

@@ -0,0 +1,27 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.kscript = void 0;
+exports.kscript = __importStar(require("./kscript"));

package/cjs/helpers/kscript/kscript.d.ts

@@ -0,0 +1,6 @@
+import { ContextOptions, PrototypeWhitelist, Scope } from './Context';
+import { Node } from './nodes';
+export declare function execute(code: string, scope?: Scope, options?: ContextOptions): unknown;
+export declare function compile(code: string, scope?: Scope, options?: ContextOptions): Node;
+export declare const SAFE_GLOBALS: Map<string, unknown>;
+export declare const SAFE_PROTOTYPES: PrototypeWhitelist;