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

package/esm/grpc/teletubby_pb.grpc-client.d.ts

@@ -0,0 +1,152 @@
+import type { TelemetryMessageAck } from "./teletubby_pb";
+import type { TelemetryStreamAck } from "./teletubby_pb";
+import type { TelemetryMessage } from "./teletubby_pb";
+import type { ConfigMessage } from "./teletubby_pb";
+import type { RegistrationMessage } from "./teletubby_pb";
+import type { BinaryWriteOptions } from "@protobuf-ts/runtime";
+import type { BinaryReadOptions } from "@protobuf-ts/runtime";
+import type { TelemetryQueryRequest } from "./teletubby_pb";
+import type { TelemetryRequestAck } from "./teletubby_pb";
+import type { TelemetryRequest } from "./teletubby_pb";
+import type { TelemetryStreamMessage } from "./teletubby_pb";
+import type { ReceiverStreamMessage } from "./teletubby_pb";
+import * as grpc from "@grpc/grpc-js";
+/**
+ * @generated from protobuf service teletubby.v1.TelemetryReceiver
+ */
+export interface ITelemetryReceiverClient {
+    /**
+     * Register the receiver supports bidirectional streaming. Receiver side telemetry ack is supported under bidrectional stream now
+     * TODO: merge request telemetry and telemetry query in to ReceiverStreamMessage
+     *
+     * @generated from protobuf rpc: RegisterStreamReceiver(stream teletubby.v1.ReceiverStreamMessage) returns (stream teletubby.v1.TelemetryStreamMessage);
+     */
+    registerStreamReceiver(metadata: grpc.Metadata, options?: grpc.CallOptions): grpc.ClientDuplexStream<ReceiverStreamMessage, TelemetryStreamMessage>;
+    registerStreamReceiver(options?: grpc.CallOptions): grpc.ClientDuplexStream<ReceiverStreamMessage, TelemetryStreamMessage>;
+    /**
+     * @generated from protobuf rpc: RequestTelemetry(teletubby.v1.TelemetryRequest) returns (teletubby.v1.TelemetryRequestAck);
+     */
+    requestTelemetry(input: TelemetryRequest, metadata: grpc.Metadata, options: grpc.CallOptions, callback: (err: grpc.ServiceError | null, value?: TelemetryRequestAck) => void): grpc.ClientUnaryCall;
+    requestTelemetry(input: TelemetryRequest, metadata: grpc.Metadata, callback: (err: grpc.ServiceError | null, value?: TelemetryRequestAck) => void): grpc.ClientUnaryCall;
+    requestTelemetry(input: TelemetryRequest, options: grpc.CallOptions, callback: (err: grpc.ServiceError | null, value?: TelemetryRequestAck) => void): grpc.ClientUnaryCall;
+    requestTelemetry(input: TelemetryRequest, callback: (err: grpc.ServiceError | null, value?: TelemetryRequestAck) => void): grpc.ClientUnaryCall;
+    /**
+     * Through telemetry query, user can specify the query of the callsign with the predicates. The subscriber can subscribe to telemetry sources from dynamic callsigns.
+     * Multiple calls to RequestTelemetryQuery with same subscribe ID will overwrite the query from previous requests.
+     *
+     * @generated from protobuf rpc: RequestTelemetryQuery(teletubby.v1.TelemetryQueryRequest) returns (teletubby.v1.TelemetryRequestAck);
+     */
+    requestTelemetryQuery(input: TelemetryQueryRequest, metadata: grpc.Metadata, options: grpc.CallOptions, callback: (err: grpc.ServiceError | null, value?: TelemetryRequestAck) => void): grpc.ClientUnaryCall;
+    requestTelemetryQuery(input: TelemetryQueryRequest, metadata: grpc.Metadata, callback: (err: grpc.ServiceError | null, value?: TelemetryRequestAck) => void): grpc.ClientUnaryCall;
+    requestTelemetryQuery(input: TelemetryQueryRequest, options: grpc.CallOptions, callback: (err: grpc.ServiceError | null, value?: TelemetryRequestAck) => void): grpc.ClientUnaryCall;
+    requestTelemetryQuery(input: TelemetryQueryRequest, callback: (err: grpc.ServiceError | null, value?: TelemetryRequestAck) => void): grpc.ClientUnaryCall;
+}
+/**
+ * @generated from protobuf service teletubby.v1.TelemetryReceiver
+ */
+export declare class TelemetryReceiverClient extends grpc.Client implements ITelemetryReceiverClient {
+    private readonly _binaryOptions;
+    constructor(address: string, credentials: grpc.ChannelCredentials, options?: grpc.ClientOptions, binaryOptions?: Partial<BinaryReadOptions & BinaryWriteOptions>);
+    /**
+     * Register the receiver supports bidirectional streaming. Receiver side telemetry ack is supported under bidrectional stream now
+     * TODO: merge request telemetry and telemetry query in to ReceiverStreamMessage
+     *
+     * @generated from protobuf rpc: RegisterStreamReceiver(stream teletubby.v1.ReceiverStreamMessage) returns (stream teletubby.v1.TelemetryStreamMessage);
+     */
+    registerStreamReceiver(metadata?: grpc.Metadata | grpc.CallOptions, options?: grpc.CallOptions): grpc.ClientDuplexStream<ReceiverStreamMessage, TelemetryStreamMessage>;
+    /**
+     * @generated from protobuf rpc: RequestTelemetry(teletubby.v1.TelemetryRequest) returns (teletubby.v1.TelemetryRequestAck);
+     */
+    requestTelemetry(input: TelemetryRequest, metadata: grpc.Metadata | grpc.CallOptions | ((err: grpc.ServiceError | null, value?: TelemetryRequestAck) => void), options?: grpc.CallOptions | ((err: grpc.ServiceError | null, value?: TelemetryRequestAck) => void), callback?: ((err: grpc.ServiceError | null, value?: TelemetryRequestAck) => void)): grpc.ClientUnaryCall;
+    /**
+     * Through telemetry query, user can specify the query of the callsign with the predicates. The subscriber can subscribe to telemetry sources from dynamic callsigns.
+     * Multiple calls to RequestTelemetryQuery with same subscribe ID will overwrite the query from previous requests.
+     *
+     * @generated from protobuf rpc: RequestTelemetryQuery(teletubby.v1.TelemetryQueryRequest) returns (teletubby.v1.TelemetryRequestAck);
+     */
+    requestTelemetryQuery(input: TelemetryQueryRequest, metadata: grpc.Metadata | grpc.CallOptions | ((err: grpc.ServiceError | null, value?: TelemetryRequestAck) => void), options?: grpc.CallOptions | ((err: grpc.ServiceError | null, value?: TelemetryRequestAck) => void), callback?: ((err: grpc.ServiceError | null, value?: TelemetryRequestAck) => void)): grpc.ClientUnaryCall;
+}
+/**
+ * Will be deprecated in the future
+ *
+ * @generated from protobuf service teletubby.v1.TelemetryGateway
+ */
+export interface ITelemetryGatewayClient {
+    /**
+     * @generated from protobuf rpc: RegisterSender(teletubby.v1.RegistrationMessage) returns (stream teletubby.v1.ConfigMessage);
+     */
+    registerSender(input: RegistrationMessage, metadata?: grpc.Metadata, options?: grpc.CallOptions): grpc.ClientReadableStream<ConfigMessage>;
+    registerSender(input: RegistrationMessage, options?: grpc.CallOptions): grpc.ClientReadableStream<ConfigMessage>;
+    /**
+     * @generated from protobuf rpc: RegisterReceiver(teletubby.v1.RegistrationMessage) returns (stream teletubby.v1.TelemetryMessage);
+     */
+    registerReceiver(input: RegistrationMessage, metadata?: grpc.Metadata, options?: grpc.CallOptions): grpc.ClientReadableStream<TelemetryMessage>;
+    registerReceiver(input: RegistrationMessage, options?: grpc.CallOptions): grpc.ClientReadableStream<TelemetryMessage>;
+    /**
+     * @generated from protobuf rpc: SendTelemetry(stream teletubby.v1.TelemetryMessage) returns (teletubby.v1.TelemetryStreamAck);
+     */
+    sendTelemetry(metadata: grpc.Metadata, options: grpc.CallOptions, callback: (err: grpc.ServiceError | null, value?: TelemetryStreamAck) => void): grpc.ClientWritableStream<TelemetryMessage>;
+    sendTelemetry(metadata: grpc.Metadata, callback: (err: grpc.ServiceError | null, value?: TelemetryStreamAck) => void): grpc.ClientWritableStream<TelemetryMessage>;
+    sendTelemetry(options: grpc.CallOptions, callback: (err: grpc.ServiceError | null, value?: TelemetryStreamAck) => void): grpc.ClientWritableStream<TelemetryMessage>;
+    sendTelemetry(callback: (err: grpc.ServiceError | null, value?: TelemetryStreamAck) => void): grpc.ClientWritableStream<TelemetryMessage>;
+    /**
+     * @generated from protobuf rpc: SendTelemetryMessage(teletubby.v1.TelemetryMessage) returns (teletubby.v1.TelemetryMessageAck);
+     */
+    sendTelemetryMessage(input: TelemetryMessage, metadata: grpc.Metadata, options: grpc.CallOptions, callback: (err: grpc.ServiceError | null, value?: TelemetryMessageAck) => void): grpc.ClientUnaryCall;
+    sendTelemetryMessage(input: TelemetryMessage, metadata: grpc.Metadata, callback: (err: grpc.ServiceError | null, value?: TelemetryMessageAck) => void): grpc.ClientUnaryCall;
+    sendTelemetryMessage(input: TelemetryMessage, options: grpc.CallOptions, callback: (err: grpc.ServiceError | null, value?: TelemetryMessageAck) => void): grpc.ClientUnaryCall;
+    sendTelemetryMessage(input: TelemetryMessage, callback: (err: grpc.ServiceError | null, value?: TelemetryMessageAck) => void): grpc.ClientUnaryCall;
+    /**
+     * @generated from protobuf rpc: RequestTelemetry(teletubby.v1.TelemetryRequest) returns (teletubby.v1.TelemetryRequestAck);
+     */
+    requestTelemetry(input: TelemetryRequest, metadata: grpc.Metadata, options: grpc.CallOptions, callback: (err: grpc.ServiceError | null, value?: TelemetryRequestAck) => void): grpc.ClientUnaryCall;
+    requestTelemetry(input: TelemetryRequest, metadata: grpc.Metadata, callback: (err: grpc.ServiceError | null, value?: TelemetryRequestAck) => void): grpc.ClientUnaryCall;
+    requestTelemetry(input: TelemetryRequest, options: grpc.CallOptions, callback: (err: grpc.ServiceError | null, value?: TelemetryRequestAck) => void): grpc.ClientUnaryCall;
+    requestTelemetry(input: TelemetryRequest, callback: (err: grpc.ServiceError | null, value?: TelemetryRequestAck) => void): grpc.ClientUnaryCall;
+    /**
+     * Through telemetry query, user can specify the query of the callsign with the predicates. The subscriber can subscribe to telemetry sources from dynamic callsigns.
+     * Multiple calls to RequestTelemetryQuery with same subscribe ID will overwrite the query from previous requests.
+     *
+     * @generated from protobuf rpc: RequestTelemetryQuery(teletubby.v1.TelemetryQueryRequest) returns (teletubby.v1.TelemetryRequestAck);
+     */
+    requestTelemetryQuery(input: TelemetryQueryRequest, metadata: grpc.Metadata, options: grpc.CallOptions, callback: (err: grpc.ServiceError | null, value?: TelemetryRequestAck) => void): grpc.ClientUnaryCall;
+    requestTelemetryQuery(input: TelemetryQueryRequest, metadata: grpc.Metadata, callback: (err: grpc.ServiceError | null, value?: TelemetryRequestAck) => void): grpc.ClientUnaryCall;
+    requestTelemetryQuery(input: TelemetryQueryRequest, options: grpc.CallOptions, callback: (err: grpc.ServiceError | null, value?: TelemetryRequestAck) => void): grpc.ClientUnaryCall;
+    requestTelemetryQuery(input: TelemetryQueryRequest, callback: (err: grpc.ServiceError | null, value?: TelemetryRequestAck) => void): grpc.ClientUnaryCall;
+}
+/**
+ * Will be deprecated in the future
+ *
+ * @generated from protobuf service teletubby.v1.TelemetryGateway
+ */
+export declare class TelemetryGatewayClient extends grpc.Client implements ITelemetryGatewayClient {
+    private readonly _binaryOptions;
+    constructor(address: string, credentials: grpc.ChannelCredentials, options?: grpc.ClientOptions, binaryOptions?: Partial<BinaryReadOptions & BinaryWriteOptions>);
+    /**
+     * @generated from protobuf rpc: RegisterSender(teletubby.v1.RegistrationMessage) returns (stream teletubby.v1.ConfigMessage);
+     */
+    registerSender(input: RegistrationMessage, metadata?: grpc.Metadata | grpc.CallOptions, options?: grpc.CallOptions): grpc.ClientReadableStream<ConfigMessage>;
+    /**
+     * @generated from protobuf rpc: RegisterReceiver(teletubby.v1.RegistrationMessage) returns (stream teletubby.v1.TelemetryMessage);
+     */
+    registerReceiver(input: RegistrationMessage, metadata?: grpc.Metadata | grpc.CallOptions, options?: grpc.CallOptions): grpc.ClientReadableStream<TelemetryMessage>;
+    /**
+     * @generated from protobuf rpc: SendTelemetry(stream teletubby.v1.TelemetryMessage) returns (teletubby.v1.TelemetryStreamAck);
+     */
+    sendTelemetry(metadata: grpc.Metadata | grpc.CallOptions | ((err: grpc.ServiceError | null, value?: TelemetryStreamAck) => void), options?: grpc.CallOptions | ((err: grpc.ServiceError | null, value?: TelemetryStreamAck) => void), callback?: ((err: grpc.ServiceError | null, value?: TelemetryStreamAck) => void)): grpc.ClientWritableStream<TelemetryMessage>;
+    /**
+     * @generated from protobuf rpc: SendTelemetryMessage(teletubby.v1.TelemetryMessage) returns (teletubby.v1.TelemetryMessageAck);
+     */
+    sendTelemetryMessage(input: TelemetryMessage, metadata: grpc.Metadata | grpc.CallOptions | ((err: grpc.ServiceError | null, value?: TelemetryMessageAck) => void), options?: grpc.CallOptions | ((err: grpc.ServiceError | null, value?: TelemetryMessageAck) => void), callback?: ((err: grpc.ServiceError | null, value?: TelemetryMessageAck) => void)): grpc.ClientUnaryCall;
+    /**
+     * @generated from protobuf rpc: RequestTelemetry(teletubby.v1.TelemetryRequest) returns (teletubby.v1.TelemetryRequestAck);
+     */
+    requestTelemetry(input: TelemetryRequest, metadata: grpc.Metadata | grpc.CallOptions | ((err: grpc.ServiceError | null, value?: TelemetryRequestAck) => void), options?: grpc.CallOptions | ((err: grpc.ServiceError | null, value?: TelemetryRequestAck) => void), callback?: ((err: grpc.ServiceError | null, value?: TelemetryRequestAck) => void)): grpc.ClientUnaryCall;
+    /**
+     * Through telemetry query, user can specify the query of the callsign with the predicates. The subscriber can subscribe to telemetry sources from dynamic callsigns.
+     * Multiple calls to RequestTelemetryQuery with same subscribe ID will overwrite the query from previous requests.
+     *
+     * @generated from protobuf rpc: RequestTelemetryQuery(teletubby.v1.TelemetryQueryRequest) returns (teletubby.v1.TelemetryRequestAck);
+     */
+    requestTelemetryQuery(input: TelemetryQueryRequest, metadata: grpc.Metadata | grpc.CallOptions | ((err: grpc.ServiceError | null, value?: TelemetryRequestAck) => void), options?: grpc.CallOptions | ((err: grpc.ServiceError | null, value?: TelemetryRequestAck) => void), callback?: ((err: grpc.ServiceError | null, value?: TelemetryRequestAck) => void)): grpc.ClientUnaryCall;
+}

package/esm/helpers/arrayRemove.d.ts

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

package/esm/helpers/arrayUnique.d.ts

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

package/esm/helpers/average.d.ts

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

package/esm/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/esm/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/esm/helpers/cleanObject.d.ts

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

package/esm/helpers/cleanObject.js

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

package/esm/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/esm/helpers/flattenCallsignsLookup.d.ts

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

package/esm/helpers/flattenObject.d.ts

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

package/esm/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/esm/helpers/formatServiceUrl.d.ts

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

package/esm/helpers/generateUUID.d.ts

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

package/esm/helpers/getSha256Hex.d.ts

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

package/esm/helpers/getSha256Hex.js

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

package/esm/helpers/getSha256HexNode.d.ts

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

package/esm/helpers/getSha256HexNode.js

@@ -0,0 +1,6 @@
+import crypto from 'crypto';
+export const getSha256HexNode = 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('');
+};

package/esm/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/esm/helpers/getURLSearchParams.d.ts

@@ -0,0 +1,2 @@
+export type QueryParams = Record<string, string | number | boolean> | URLSearchParams;
+export declare const getURLSearchParams: (params: QueryParams) => URLSearchParams;

package/esm/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/esm/helpers/getUniqueConfigKey.js

@@ -0,0 +1,19 @@
+/**
+ * Flattens and orders the sdk config props to make a unique key
+ *
+ * @param config - SDK config {@link IRocosSDKConfig}
+ */
+export 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();
+};

package/esm/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/esm/helpers/getUnixTimeMs.d.ts

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

package/esm/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/esm/helpers/index.js

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

package/esm/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/esm/helpers/kscript/Context.js

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

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

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

package/esm/helpers/kscript/index.js

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

package/esm/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;