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

package/esm/helpers/websandbox/sandbox.d.ts

@@ -0,0 +1,57 @@
+export interface SandboxOptions extends Required<RunCodeOptions> {
+    /** The selector or element to append the iframe to */
+    frameContainer: string | Element;
+    /** Whether to enable verbose logging */
+    debugMode: boolean;
+}
+export interface RunCodeOptions {
+    /** The name of the variable to use for the context object */
+    contextVariable?: string;
+    timeout?: {
+        /** The minimum time to wait for a task to complete
+         *
+         * The worker will attempt to kill the task after this time.
+         */
+        minimumMs: number;
+        /** The maximum time to wait for a task to complete
+         *
+         * The sandbox will be destroyed and rebuilt after this time.
+         */
+        maximumMs: number;
+    };
+    abortSignal?: AbortSignal | null;
+}
+export declare const BaseOptions: SandboxOptions;
+export interface SandboxMethods {
+    iframeInitialised: () => void;
+}
+/** A sandbox for running untrusted code in an iframe & embedded web worker.
+ *
+ * This is a wrapper around the iframe and web worker that provides a simple API for running code in the sandbox.
+ * It also provides a context object that can be used to pass data into the sandbox.
+ */
+export default class WebSandbox {
+    private readonly options;
+    private frame;
+    private connection?;
+    private initialised;
+    private frameAbortController;
+    static new(options?: Partial<SandboxOptions>): Promise<WebSandbox>;
+    private constructor();
+    /** Runs code in the sandbox. Can be either a string or a function */
+    run<T = unknown>(code: string | (() => T), context?: unknown, options?: RunCodeOptions): Promise<T>;
+    /** Destroys the sandbox.
+     *
+     * This will remove the iframe from the DOM and remove the message listener.
+     */
+    destroy(): void;
+    private initialise;
+    private validateOptions;
+    private destroyAndRebuild;
+    private removeMessageListener;
+    private runFunction;
+    private runCode;
+    private promisifyAbortSignal;
+    private createFrame;
+    private prepareFrameContent;
+}

package/esm/helpers/websandbox/types.d.ts

@@ -0,0 +1,13 @@
+type APIMethod = (...args: any[]) => unknown;
+export type API = Map<string, APIMethod>;
+export type APIDeclaration<T> = {
+    [K in keyof T]: T[K] extends APIMethod ? T[K] : never;
+};
+export interface Task {
+    id: string;
+    code: string;
+    context?: unknown;
+    timeout: number;
+    contextVariable?: string;
+}
+export {};

package/esm/index.js

@@ -0,0 +1,7 @@
+export * from './constants/grpc';
+export * from './constants/timezones';
+export * from './helpers';
+export * from './models';
+export * from './services';
+export * from './IRocosSDK';
+export * from './RocosSDK';

package/esm/logger/RocosLogger.d.ts

@@ -0,0 +1,7 @@
+import { LogLevelDesc, Logger } from 'loglevel';
+export declare class RocosLogger {
+    static getInstance(name?: string): Logger;
+    static enableAll(): void;
+    static disableAll(): void;
+    static setLevel(level: LogLevelDesc): void;
+}

package/esm/models/CallsignStatus.d.ts

@@ -0,0 +1,6 @@
+export declare enum CallsignStatus {
+    UNKNOWN = "unknown",
+    ONLINE = "online",
+    OFFLINE = "offline",
+    ERROR = "error"
+}

package/esm/models/ExportDataQuery.d.ts

@@ -0,0 +1,8 @@
+import { IExportDataQuery, IExportDataQueryFilter } from './IExportDataQuery';
+export declare class ExportDataQuery implements IExportDataQuery {
+    startDate: Date;
+    endDate: Date;
+    filters: IExportDataQueryFilter[];
+    constructor(init?: Partial<IExportDataQuery>);
+    toJSON(): any;
+}

package/esm/models/ExternalProject.d.ts

@@ -0,0 +1,6 @@
+export declare class ExternalProject {
+    id?: string;
+    name?: string;
+    createdAt?: number;
+    isLinked?: boolean;
+}

package/esm/models/IBaseService.d.ts

@@ -0,0 +1,4 @@
+export interface IBaseService {
+    getStatus: () => boolean;
+    teardown?: (() => void) | (() => Promise<void>);
+}

package/esm/models/IConfigGroup.d.ts

@@ -0,0 +1,5 @@
+export interface IConfigGroup {
+    id: string;
+    name: string;
+    config: any[];
+}

package/esm/models/IDebugLevel.d.ts

@@ -0,0 +1,2 @@
+import { LogLevelDesc } from 'loglevel';
+export type IDebugLevel = LogLevelDesc;

package/esm/models/IExportDataQuery.d.ts

@@ -0,0 +1,9 @@
+export interface IExportDataQueryFilter {
+    keyword: string;
+    ids: string[];
+}
+export interface IExportDataQuery {
+    startDate: Date;
+    endDate: Date;
+    filters: IExportDataQueryFilter[];
+}

package/esm/models/IFunctionConfig.d.ts

@@ -0,0 +1,8 @@
+export interface IFunctionConfig {
+    id: string;
+    name: string;
+    handler: string;
+    runtime: string;
+    function: string;
+    deps: string[];
+}

package/esm/models/IInvitation.d.ts

@@ -0,0 +1,6 @@
+export type IInvitationType = 'PROJECT' | 'SIGNUP';
+export interface IInvitation {
+    email: string;
+    type: IInvitationType;
+    ids: string[];
+}

package/esm/models/IInvitationExists.d.ts

@@ -0,0 +1,4 @@
+export interface IInvitationExists {
+    accountExists: boolean;
+    accepted: boolean;
+}

package/esm/models/IOperation.d.ts

@@ -0,0 +1,6 @@
+export interface IOperation {
+    name: string;
+    pageType: string;
+    payload?: string;
+    description?: string;
+}

package/esm/models/IPersonalAccessToken.d.ts

@@ -0,0 +1,16 @@
+export interface IPersonalAccessToken {
+    name: string;
+    pat?: string;
+    ttlDays: number;
+    scope: string[];
+    projectId: string;
+    robotDefinitionId?: string;
+    metaData: IPersonalAccessTokenMetadata;
+    expiry?: Date;
+}
+interface IPersonalAccessTokenMetadata {
+    singleUse?: boolean;
+    defaultRobotDefinitionId?: string;
+    [key: string]: unknown;
+}
+export {};

package/esm/models/IProject.d.ts

@@ -0,0 +1,4 @@
+export interface IProject {
+    name: string;
+    description: string;
+}

package/esm/models/IProjectApplication.d.ts

@@ -0,0 +1,6 @@
+export interface IProjectApplication {
+    id?: string;
+    name: string;
+    secret?: string;
+    tokenExpiryInMinutes: number;
+}

package/esm/models/IRobot.d.ts

@@ -0,0 +1,18 @@
+import { RobotModeType } from './types';
+export interface IRobot {
+    tags?: string[];
+    name: string;
+    callsign: string;
+    disabled: boolean;
+    imageId: string;
+    mode: RobotModeType;
+    description?: string;
+    configParameters?: string;
+    robotDefinition?: string;
+    projectId?: string;
+    componentSettingsVersionLog?: string[];
+    createdAt?: string;
+    updatedAt?: string;
+    robotDefinitionName?: string;
+    robotDefinitionTags?: string[];
+}

package/esm/models/IRobotConfig.d.ts

@@ -0,0 +1,8 @@
+export interface IRobotConfig {
+    id: string;
+    name: string;
+    description: string;
+    type: string;
+    defaultValue: any;
+    required: boolean;
+}

package/esm/models/IRobotPlugin.d.ts

@@ -0,0 +1,3 @@
+export interface IRobotPlugin {
+    name: string;
+}

package/esm/models/IRobotSettings.d.ts

@@ -0,0 +1,28 @@
+export interface IRobotSettings {
+    type: "settings";
+    items: {
+        id: string;
+        value: {
+            /**
+             * The actual settings object for this specific setting type
+             */
+            settings: Record<string, any>;
+            /**
+             * The ID of the setting type, usually one of: ops-global-settings, ops-local-settings, flight-app-settings
+             */
+            id: 'ops-global-settings' | 'ops-local-settings' | 'flight-app-settings' | string;
+            enabled: boolean;
+        };
+    }[];
+    version: number;
+    robotDefinitionId: string;
+    username: string;
+    /**
+     * Date in ISO format
+     */
+    createdAt: string;
+    /**
+     * Date in ISO format
+     */
+    updatedAt: string;
+}

package/esm/models/IRobotTemplate.d.ts

@@ -0,0 +1,10 @@
+import { IRobotConfig } from './IRobotConfig';
+import { IRobotPlugin } from './IRobotPlugin';
+export interface IRobotTemplate {
+    id: string;
+    name: string;
+    description?: string;
+    parameters: IRobotConfig[];
+    metaData: any;
+    plugins: IRobotPlugin[];
+}

package/esm/models/IRocosSDKConfig.d.ts

@@ -0,0 +1,23 @@
+import { IStreamOptions } from './IStreamOptions';
+import { ServiceEnum } from './ServiceEnum';
+export type IRocosSDKConfig = AuthorisedConfig & {
+    overrides?: Partial<Record<ServiceEnum, Partial<AuthorisedConfig>>>;
+};
+interface ConfigBase {
+    url: string;
+    token?: string;
+    refreshToken?: string;
+    options?: IStreamOptions;
+    port?: number;
+    insecure?: boolean;
+}
+export interface IRocosSDKConfigApp extends ConfigBase {
+    appId: string;
+    appKey: string;
+}
+export interface IRocosSDKConfigToken extends ConfigBase {
+    token: string;
+    refreshToken?: string;
+}
+export type AuthorisedConfig = IRocosSDKConfigApp | IRocosSDKConfigToken;
+export {};

package/esm/models/ISource.d.ts

@@ -0,0 +1,8 @@
+export interface ISourceData {
+    id: string;
+}
+export interface ISource {
+    id: string;
+    name: string;
+    data?: ISourceData[];
+}

package/esm/models/IStream.d.ts

@@ -0,0 +1,9 @@
+import { IStreamSource } from './IStreamSource';
+export interface IStream {
+    id?: string;
+    name: string;
+    description?: string;
+    data: IStreamSource[];
+    callsigns?: string[];
+    robotDefinitionIds?: any;
+}

package/esm/models/IStreamConfig.d.ts

@@ -0,0 +1,9 @@
+import { IStreamOptions } from './IStreamOptions';
+export interface IStreamConfig {
+    url: string;
+    token: string;
+    scope: string;
+    options?: IStreamOptions;
+    port?: number;
+    insecure?: boolean;
+}

package/esm/models/IStreamOptions.d.ts

@@ -0,0 +1,7 @@
+export interface IStreamOptions {
+    autoResubscribeEnabled: boolean;
+    autoResubscribeMessageLimit: number;
+    autoResubscribeMinimumTime: number;
+    messageTimeoutInSec: number;
+    autoAcknowledgmentEnabled: boolean;
+}

package/esm/models/IStreamSource.d.ts

@@ -0,0 +1,8 @@
+export interface IStreamSource {
+    id?: string;
+    sourceId: string;
+    dataId: string;
+    type: string;
+    frequency: number;
+    robotDefinitionIds?: any;
+}

package/esm/models/ISubscriberStatus.d.ts

@@ -0,0 +1,5 @@
+import { Observable } from 'rxjs';
+import { SubscriberStatusEnum } from './SubscriberStatusEnum';
+export interface ISubscriberStatus {
+    status$: Observable<SubscriberStatusEnum>;
+}

package/esm/models/ITelemetryStreamConfig.d.ts

@@ -0,0 +1,7 @@
+import { CallsignsLookup } from './callsigns/CallsignsLookup';
+import { IStreamConfig } from './IStreamConfig';
+export interface ITelemetryStreamConfig extends IStreamConfig {
+    projectId: string;
+    callsignsLookup: CallsignsLookup;
+    sources: string[];
+}

package/esm/models/IToken.d.ts

@@ -0,0 +1,9 @@
+export interface IToken {
+    readonly value: string;
+    readonly expires?: Date;
+    readonly issuedAt?: Date;
+    readonly subject?: string;
+    readonly issuer?: string;
+    readonly audience?: string;
+    readonly refreshToken?: string;
+}

package/esm/models/IWidget.d.ts

@@ -0,0 +1,25 @@
+import { IWidgetLineGroup } from './IWidgetLineGroup';
+export interface IWidget {
+    connectionType: string;
+    widgetType: string;
+    widgetHeading: string;
+    dataURI: string;
+    source?: string;
+    units: string;
+    dataName: string;
+    key?: string;
+    valueExpression?: string;
+    decimalPlaces?: number;
+    widgetTimeout?: number;
+    minimumValue: number;
+    maximumValue: number;
+    lineGroups?: IWidgetLineGroup[];
+    rangeMin?: number;
+    rangeMax?: number;
+    tableFormat?: string;
+    videoServer?: string;
+    videoId?: string;
+    videoCommand?: string;
+    videoSourceType?: string;
+    html?: string;
+}

package/esm/models/IWidgetLineGroup.d.ts

@@ -0,0 +1,8 @@
+export interface IWidgetLineGroup {
+    dataURI: string;
+    source?: string;
+    units: string;
+    dataLabel: string;
+    lineColor: string;
+    valueExpression?: string;
+}

package/esm/models/ResponseLevelEnum.d.ts

@@ -0,0 +1,10 @@
+export declare enum ResponseLevelEnum {
+    /** ack, return, result **/
+    ALL = 0,
+    /** return, result **/
+    RETURN_AND_RESULT = 1,
+    /** result **/
+    RESULT_ONLY = 2,
+    /** nothing **/
+    NONE = 3
+}

package/esm/models/Robot.d.ts

@@ -0,0 +1,20 @@
+import { IRobot } from './IRobot';
+import { RobotModeType } from './types';
+export declare class Robot implements IRobot {
+    tags?: string[];
+    name: string;
+    callsign: string;
+    disabled: boolean;
+    imageId: string;
+    mode: RobotModeType;
+    description?: string;
+    configParameters?: string;
+    robotDefinition?: string;
+    projectId?: string;
+    componentSettingsVersionLog?: string[];
+    createdAt?: string;
+    updatedAt?: string;
+    robotDefinitionName?: string;
+    robotDefinitionTags?: string[];
+    constructor(init?: Partial<IRobot>);
+}

package/esm/models/RobotConfig.d.ts

@@ -0,0 +1,10 @@
+import { IRobotConfig } from './IRobotConfig';
+export declare class RobotConfig implements IRobotConfig {
+    id: string;
+    name: string;
+    description: string;
+    type: string;
+    defaultValue: any;
+    required: boolean;
+    constructor(init?: Partial<IRobotConfig>);
+}

package/esm/models/RobotPlugin.d.ts

@@ -0,0 +1,5 @@
+import { IRobotPlugin } from './IRobotPlugin';
+export declare class RobotPlugin implements IRobotPlugin {
+    name: string;
+    constructor(init?: Partial<IRobotPlugin>);
+}

package/esm/models/RobotTemplate.d.ts

@@ -0,0 +1,12 @@
+import { IRobotConfig } from './IRobotConfig';
+import { IRobotPlugin } from './IRobotPlugin';
+import { IRobotTemplate } from './IRobotTemplate';
+export declare class RobotTemplate implements IRobotTemplate {
+    id: string;
+    name: string;
+    description?: string;
+    parameters: IRobotConfig[];
+    metaData: any;
+    plugins: IRobotPlugin[];
+    constructor(init?: Partial<IRobotTemplate>);
+}

package/esm/models/RocosError.d.ts

@@ -0,0 +1,32 @@
+export declare const errorCodes: {
+    SKD_ERROR: string;
+    AUTH_ERROR: string;
+    ROBOT_SERVICE_ERROR: string;
+    SPOT_SERVICE_ERROR: string;
+    STREAM_LISTENER_ERROR: string;
+    TELEMETRY_ERROR: string;
+    TELEMETRY_STREAM_ERROR: string;
+    TELEMETRY_SERVICE_ERROR: string;
+    EVENT_SERVICE_ERROR: string;
+    PROJECT_SERVICE_ERROR: string;
+    DASHBOARD_SERVICE_ERROR: string;
+    USER_SERVICE_ERROR: string;
+    ACCOUNT_SERVICE_ERROR: string;
+    TIME_SYNCER_SERVICE_ERROR: string;
+    CONFIG_GROUP_SERVICE_ERROR: string;
+    FUNCTION_SERVICE_ERROR: string;
+    STREAM_SERVICE_ERROR: string;
+    WORKFLOW_SERVICE_ERROR: string;
+    ASSET_STORAGE_SERVICE_ERROR: string;
+    PROFILE_SERVICE_ERROR: string;
+    SCHEDULE_SERVICE_ERROR: string;
+    INTEGRATIONS_SERVICE_ERROR: string;
+    MAPS_SERVICE_ERROR: string;
+    EVALUATOR_SERVICE_ERROR: string;
+    WEBRTC_SERVICE_ERROR: string;
+};
+export declare class RocosError extends Error {
+    code?: string;
+    statusCode?: number;
+    constructor(err: string | Error, code?: string, statusCode?: number);
+}

package/esm/models/RocosError.js

@@ -0,0 +1,41 @@
+export const errorCodes = {
+    SKD_ERROR: 'SKD_ERROR',
+    AUTH_ERROR: 'AUTH_ERROR',
+    ROBOT_SERVICE_ERROR: 'ROBOT_SERVICE_ERROR',
+    SPOT_SERVICE_ERROR: 'SPOT_SERVICE_ERROR',
+    STREAM_LISTENER_ERROR: 'STREAM_LISTENER_ERROR',
+    TELEMETRY_ERROR: 'TELEMETRY_ERROR',
+    TELEMETRY_STREAM_ERROR: 'TELEMETRY_STREAM_ERROR',
+    TELEMETRY_SERVICE_ERROR: 'TELEMETRY_SERVICE_ERROR',
+    EVENT_SERVICE_ERROR: 'EVENT_SERVICE_ERROR',
+    PROJECT_SERVICE_ERROR: 'PROJECT_SERVICE_ERROR',
+    DASHBOARD_SERVICE_ERROR: 'PROJECT_SERVICE_ERROR',
+    USER_SERVICE_ERROR: 'USER_SERVICE_ERROR',
+    ACCOUNT_SERVICE_ERROR: 'ACCOUNT_SERVICE_ERROR',
+    TIME_SYNCER_SERVICE_ERROR: 'TIME_SYNCER_SERVICE_ERROR',
+    CONFIG_GROUP_SERVICE_ERROR: 'CONFIG_GROUP_SERVICE_ERROR',
+    FUNCTION_SERVICE_ERROR: 'FUNCTION_SERVICE_ERROR',
+    STREAM_SERVICE_ERROR: 'STREAM_SERVICE_ERROR',
+    WORKFLOW_SERVICE_ERROR: 'WORKFLOW_SERVICE_ERROR',
+    ASSET_STORAGE_SERVICE_ERROR: 'ASSET_STORAGE_SERVICE_ERROR',
+    PROFILE_SERVICE_ERROR: 'PROFILE_SERVICE_ERROR',
+    SCHEDULE_SERVICE_ERROR: 'SCHEDULE_SERVICE_ERROR',
+    INTEGRATIONS_SERVICE_ERROR: 'INTEGRATIONS_SERVICE_ERROR',
+    MAPS_SERVICE_ERROR: 'MAPS_SERVICE_ERROR',
+    EVALUATOR_SERVICE_ERROR: 'EVALUATOR_SERVICE_ERROR',
+    WEBRTC_SERVICE_ERROR: 'WEBRTC_SERVICE_ERROR',
+};
+export class RocosError extends Error {
+    constructor(err, code, statusCode) {
+        if (err instanceof Error) {
+            super(err.message);
+            this.name = err.name;
+            this.stack = err.stack;
+        }
+        else {
+            super(err);
+        }
+        this.code = code;
+        this.statusCode = statusCode;
+    }
+}

package/esm/models/ServiceEnum.d.ts

@@ -0,0 +1,28 @@
+export declare enum ServiceEnum {
+    AUTH = "auth",
+    TELEMETRY = "telemetry",
+    ROBOT = "robot",
+    EVENT = "event",
+    PROJECT = "project",
+    CALLER = "caller",
+    COMMAND = "command",
+    CONTROL = "control",
+    SEARCH = "search",
+    CONFIG_GROUP = "config_group",
+    DASHBOARD = "dashboard",
+    FUNCTION = "function",
+    STREAM = "stream",
+    USER = "user",
+    TIME_SYNCER = "time_syncer",
+    WORKFLOW = "workflow",
+    ASSET_STORAGE = "asset_storage",
+    PROFILE = "profile",
+    WEBRTC_SIGNALLING = "webrtc_signalling",
+    FILE_ACCESSOR = "file_accessor",
+    SCHEDULE = "schedule",
+    SPOT_PROVISIONER = "spot_provisioner",
+    INTEGRATION = "integration",
+    MAP = "map",
+    EVALUATOR = "evaluator",
+    RTP_WEBRTC = "rtp_webrtc"
+}

package/esm/models/ServiceEnum.js

@@ -0,0 +1,29 @@
+export var ServiceEnum;
+(function (ServiceEnum) {
+    ServiceEnum["AUTH"] = "auth";
+    ServiceEnum["TELEMETRY"] = "telemetry";
+    ServiceEnum["ROBOT"] = "robot";
+    ServiceEnum["EVENT"] = "event";
+    ServiceEnum["PROJECT"] = "project";
+    ServiceEnum["CALLER"] = "caller";
+    ServiceEnum["COMMAND"] = "command";
+    ServiceEnum["CONTROL"] = "control";
+    ServiceEnum["SEARCH"] = "search";
+    ServiceEnum["CONFIG_GROUP"] = "config_group";
+    ServiceEnum["DASHBOARD"] = "dashboard";
+    ServiceEnum["FUNCTION"] = "function";
+    ServiceEnum["STREAM"] = "stream";
+    ServiceEnum["USER"] = "user";
+    ServiceEnum["TIME_SYNCER"] = "time_syncer";
+    ServiceEnum["WORKFLOW"] = "workflow";
+    ServiceEnum["ASSET_STORAGE"] = "asset_storage";
+    ServiceEnum["PROFILE"] = "profile";
+    ServiceEnum["WEBRTC_SIGNALLING"] = "webrtc_signalling";
+    ServiceEnum["FILE_ACCESSOR"] = "file_accessor";
+    ServiceEnum["SCHEDULE"] = "schedule";
+    ServiceEnum["SPOT_PROVISIONER"] = "spot_provisioner";
+    ServiceEnum["INTEGRATION"] = "integration";
+    ServiceEnum["MAP"] = "map";
+    ServiceEnum["EVALUATOR"] = "evaluator";
+    ServiceEnum["RTP_WEBRTC"] = "rtp_webrtc";
+})(ServiceEnum || (ServiceEnum = {}));

package/esm/models/Stream.d.ts

@@ -0,0 +1,10 @@
+import { IStream } from './IStream';
+import { IStreamSource } from './IStreamSource';
+export declare class Stream implements IStream {
+    id?: string;
+    name: string;
+    description: string;
+    data: IStreamSource[];
+    robotDefinitionIds?: any;
+    constructor(init?: Partial<IStream>);
+}

package/esm/models/StreamOptions.d.ts

@@ -0,0 +1,9 @@
+import { IStreamOptions } from './IStreamOptions';
+export declare class StreamOptions implements IStreamOptions {
+    autoResubscribeEnabled: boolean;
+    autoResubscribeMessageLimit: number;
+    autoResubscribeMinimumTime: number;
+    messageTimeoutInSec: number;
+    autoAcknowledgmentEnabled: boolean;
+    static fromModel(model?: Partial<IStreamOptions>): IStreamOptions;
+}

package/esm/models/StreamSource.d.ts

@@ -0,0 +1,10 @@
+import { IStreamSource } from './IStreamSource';
+export declare class StreamSource implements IStreamSource {
+    id?: string;
+    sourceId: string;
+    dataId: string;
+    type: string;
+    frequency: number;
+    robotDefinitionIds?: any;
+    constructor(init?: Partial<IStreamSource>);
+}