@dronedeploy/rocos-js-sdk 3.0.10 → 3.0.12

package/cjs/api/StreamRegister.d.ts

@@ -6,8 +6,8 @@ export declare class StreamRegister {
     private constructor();
     static getInstance(): StreamRegister;
     static getIdentifier($identifier: string, scope?: string): string;
-    addStream(stream: IBaseStream): Promise<void>;
+    addStream(stream: IBaseStream): void;
     getStream(identifier: string): IBaseStream | undefined;
-    removeStream(stream: IBaseStream): Promise<void>;
-    removeAllStreams(): Promise<boolean>;
+    removeStream(stream: IBaseStream): void;
+    removeAllStreams(): boolean;
 }

package/cjs/api/StreamRegister.js

@@ -17,10 +17,10 @@ class StreamRegister {
     static getIdentifier($identifier, scope) {
         return `${$identifier}-${scope ?? ''}`;
     }
-    async addStream(stream) {
+    addStream(stream) {
         try {
             if (this.teleStreams.has(stream.identifier)) {
-                await this.removeStream(stream);
+                this.removeStream(stream);
             }
             this.teleStreams.set(stream.identifier, stream);
         }
@@ -37,9 +37,9 @@ class StreamRegister {
     getStream(identifier) {
         return this.teleStreams.get(identifier);
     }
-    async removeStream(stream) {
+    removeStream(stream) {
         try {
-            await stream.stopStream();
+            stream.stopStream();
             this.teleStreams.delete(stream.identifier);
         }
         catch (e) {
@@ -52,10 +52,10 @@ class StreamRegister {
             }
         }
     }
-    async removeAllStreams() {
+    removeAllStreams() {
         try {
             for (const [, stream] of this.teleStreams.entries()) {
-                await this.removeStream(stream);
+                this.removeStream(stream);
             }
         }
         catch (e) {

package/cjs/api/streams/telemetry/TelemetryStreamAbstract.js

@@ -103,6 +103,14 @@ class TelemetryStreamAbstract {
         const before = this.getSubscriptions();
         this.subscriptions.delete(params.uniqueId);
         const after = this.getSubscriptions();
+        // Do this before we send the telemetry request so that new subscriptions don't get this stream from the register while it is closing
+        if (!this.subscriptions.size) {
+            this.logger.info('No subscriptions remaining closing stream', params.uniqueId);
+            this.stopStream();
+            // self remove when no subscriptions are left
+            StreamRegister_1.StreamRegister.getInstance().removeStream(this);
+            this.logger.info('Stream closed');
+        }
         // assign the current values from state after change
         this.callsignsLookup = new models_1.CallsignsLookup(Object.keys(after));
         this.sources = (0, arrayUnique_1.arrayUnique)(Object.values(after).reduce((a, v) => a.concat(v), []));
@@ -116,13 +124,6 @@ class TelemetryStreamAbstract {
                 this.logger.error(`Failed to unsubscribe: ${err}`);
             }
         }
-        if (!this.subscriptions.size) {
-            this.logger.info('No subscriptions remaining closing stream', params.uniqueId);
-            this.stopStream();
-            // self remove when no subscriptions a re left
-            void StreamRegister_1.StreamRegister.getInstance().removeStream(this);
-            this.logger.info('Stream closed');
-        }
     }
     sendAcknowledgment(uid, status, noRetry) {
         return this.sendAcknowledgmentInternal(uid, status, noRetry);

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

@@ -7,19 +7,20 @@ import type { NodeType } from './nodes';
  * 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 type Scope = Record<string, unknown> | Map<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;
+    private readonly parent;
+    private readonly scope;
+    private readonly config;
+    static create(scope?: Scope, options?: ContextOptions): Context;
+    private static buildMap;
+    private constructor();
+    newChild(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.
@@ -30,5 +31,10 @@ export default class Context {
      * @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;
+    isNodeAllowed(nodeType: AnyNode['type']): boolean;
+    get isFunctionCallAllowed(): boolean;
+    private getDescriptor;
+    get(key: string): unknown;
+    set(key: string, value: unknown): void;
+    declare(key: string, value: unknown, constant: boolean): void;
 }

package/cjs/helpers/kscript/Context.js

@@ -1,28 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 class Context {
-    constructor(scope, options) {
+    static create(scope, options) {
+        return new Context(null, {
+            functionCallsAllowed: true,
+            nodeBlacklist: new Set(),
+            prototypeWhitelist: new Map(),
+            ...(options ?? {}),
+        }, scope);
+    }
+    static buildMap(obj) {
+        const entries = obj instanceof Map ? Array.from(obj.entries()) : Object.entries(obj);
+        return new Map(entries.map(([key, value]) => [key, { value, constant: false }]));
+    }
+    constructor(parent, config, scope) {
+        this.parent = parent;
         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.config = {
+            nodeBlacklist: config.nodeBlacklist ?? new Set(),
+            prototypeWhitelist: config.prototypeWhitelist ?? new Map(),
+            functionCallsAllowed: config.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);
+    newChild(scope) {
+        return new Context(this, this.config, scope);
     }
     /** Returns true if the property is allowed to be accessed on the prototype.
      *
@@ -34,7 +35,7 @@ class Context {
      * @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);
+        const whitelist = this.config.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')
@@ -45,8 +46,44 @@ class Context {
             return true;
         return whitelist.has(property);
     }
-    static buildMap(obj) {
-        return obj instanceof Map ? obj : new Map(Object.entries(obj));
+    isNodeAllowed(nodeType) {
+        return !this.config.nodeBlacklist.has(nodeType);
+    }
+    get isFunctionCallAllowed() {
+        return this.config.functionCallsAllowed;
+    }
+    getDescriptor(key, searchParents = true) {
+        if (this.scope.has(key)) {
+            return this.scope.get(key);
+        }
+        if (searchParents && this.parent) {
+            return this.parent.getDescriptor(key);
+        }
+        return undefined;
+    }
+    get(key) {
+        const descriptor = this.getDescriptor(key);
+        if (descriptor) {
+            return descriptor.value;
+        }
+        return undefined;
+    }
+    set(key, value) {
+        const descriptor = this.getDescriptor(key);
+        if (!descriptor) {
+            throw new Error(`no variable with name ${key}`);
+        }
+        if (descriptor.constant) {
+            throw new Error(`cannot reassign to constant variable ${key}`);
+        }
+        descriptor.value = value;
+    }
+    declare(key, value, constant) {
+        const descriptor = this.getDescriptor(key, false);
+        if (descriptor) {
+            throw new Error(`variable ${key} already declared`);
+        }
+        this.scope.set(key, { value, constant });
     }
 }
 exports.default = Context;

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

@@ -1,6 +1,11 @@
 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 compile: (code: string, scope?: Scope, options?: ContextOptions) => Node;
+/** Throws an error if the code uses an invalid node.
+ *
+ * This does not check that the code will run without errors, only that the nodes used are allowed.
+ **/
+export declare const validate: (code: string, options?: ContextOptions) => void;
+export declare const execute: (code: string, scope?: Scope, options?: ContextOptions) => unknown;
 export declare const SAFE_GLOBALS: Map<string, unknown>;
 export declare const SAFE_PROTOTYPES: PrototypeWhitelist;

package/cjs/helpers/kscript/kscript.js

@@ -3,36 +3,46 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SAFE_PROTOTYPES = exports.SAFE_GLOBALS = exports.compile = exports.execute = void 0;
+exports.SAFE_PROTOTYPES = exports.SAFE_GLOBALS = exports.execute = exports.validate = exports.compile = void 0;
 const Context_1 = __importDefault(require("./Context"));
 const acorn_1 = require("acorn");
 const utils_1 = require("./utils");
-function execute(code, scope, options) {
-    return compile(code, scope, options).run();
-}
-exports.execute = execute;
-function compile(code, scope, options) {
-    let program;
+const parse = (code) => {
     try {
         // we add the brackets to ensure that object literals are parsed correctly
-        program = (0, acorn_1.parse)(`(${code})`, { ecmaVersion: 2020, sourceType: 'script' });
+        // e.g. `{ a: 1 }` is not a valid statement, but `({ a: 1 })` is
+        return (0, acorn_1.parse)(`(${code})`, { ecmaVersion: 2020, sourceType: 'script' });
     }
     catch (error) {
         if (error instanceof SyntaxError) {
             // fallback to non-wrapped code for edge cases where the brackets cause issues
-            program = (0, acorn_1.parse)(`${code}`, { ecmaVersion: 2020, sourceType: 'script' });
-        }
-        else {
-            throw error;
+            // e.g. `if (a) 2; else 4;` will throw a syntax error if wrapped in brackets
+            return (0, acorn_1.parse)(`${code}`, { ecmaVersion: 2020, sourceType: 'script' });
         }
+        throw error;
     }
-    const context = new Context_1.default(scope ?? exports.SAFE_GLOBALS, {
+};
+const compile = (code, scope, options) => {
+    const program = parse(code);
+    const context = Context_1.default.create(scope ?? exports.SAFE_GLOBALS, {
         prototypeWhitelist: exports.SAFE_PROTOTYPES,
         ...options,
     });
     return (0, utils_1.construct)(program, context);
-}
+};
 exports.compile = compile;
+/** Throws an error if the code uses an invalid node.
+ *
+ * This does not check that the code will run without errors, only that the nodes used are allowed.
+ **/
+const validate = (code, options) => {
+    (0, exports.compile)(code, undefined, options).validate(true);
+};
+exports.validate = validate;
+const execute = (code, scope, options) => {
+    return (0, exports.compile)(code, scope, options).run();
+};
+exports.execute = execute;
 exports.SAFE_GLOBALS = new Map(Object.entries({
     console: {
         debug: console.debug,

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

@@ -8,5 +8,6 @@ import Node from './Node';
  */
 export default class IdentifierNode extends Node<Identifier> {
     constructor(node: AnyNode, context: Context);
+    validate(): void;
     run(): unknown;
 }

package/cjs/helpers/kscript/nodes/Identifier.js

@@ -13,8 +13,9 @@ class IdentifierNode extends Node_1.default {
     constructor(node, context) {
         super(node, context, 'Identifier');
     }
+    validate() { }
     run() {
-        return this.scope.get(this.node.name);
+        return this.context.get(this.node.name);
     }
 }
 exports.default = IdentifierNode;

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

@@ -7,5 +7,6 @@ import Node from './Node';
  */
 export default class LiteralNode extends Node<Literal> {
     constructor(node: AnyNode, context: Context);
+    validate(): void;
     run(): unknown;
 }

package/cjs/helpers/kscript/nodes/Literal.js

@@ -12,10 +12,13 @@ class LiteralNode extends Node_1.default {
     constructor(node, context) {
         super(node, context, 'Literal');
     }
-    run() {
+    validate() {
         if (this.node.bigint) {
             throw new Error('BigInts are not supported');
         }
+    }
+    run() {
+        this.validate();
         return this.node.value;
     }
 }

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

@@ -3,7 +3,12 @@ import type Context from '../Context';
 export default abstract class Node<T extends AnyNode = AnyNode> {
     protected context: Context;
     protected node: T;
-    protected scope: Context['scope'];
     protected constructor(node: AnyNode, context: Context, expectedType: T['type'] | T['type'][]);
+    /** Runs the node. */
     abstract run(): unknown;
+    /** Validates the node. If the node is invalid, an error is thrown.
+     *
+     * if `validateChildren` is true, the children of the node will also be validated.
+     */
+    abstract validate(validateChildren: boolean): void;
 }

package/cjs/helpers/kscript/nodes/Node.js

@@ -9,7 +9,6 @@ class Node {
             throw new Error(`Expected node type to be ${expectedTypes.join(' or ')}, but got ${node.type}`);
         }
         this.node = node;
-        this.scope = context.scope;
     }
 }
 exports.default = Node;

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

@@ -7,5 +7,6 @@ import Node from './Node';
  */
 export default class ProgramNode extends Node<Program> {
     constructor(node: AnyNode, scope: Context);
+    validate(validateChildren?: boolean): void;
     run(): unknown;
 }

package/cjs/helpers/kscript/nodes/Program.js

@@ -13,12 +13,21 @@ class ProgramNode extends Node_1.default {
     constructor(node, scope) {
         super(node, scope, 'Program');
     }
+    validate(validateChildren = false) {
+        if (!validateChildren) {
+            return;
+        }
+        for (const child of this.node.body) {
+            (0, utils_1.construct)(child, this.context).validate(true);
+        }
+    }
     run() {
-        const children = this.node.body;
-        if (children.length !== 1) {
-            throw new Error('Only a single statement is supported in the sandbox');
+        this.validate();
+        let result;
+        for (const child of this.node.body) {
+            result = (0, utils_1.construct)(child, this.context).run();
         }
-        return (0, utils_1.construct)(children[0], this.context).run();
+        return result;
     }
 }
 exports.default = ProgramNode;

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

@@ -19,5 +19,6 @@ import Node from './Node';
  */
 export default class TemplateLiteralNode extends Node<TemplateLiteral> {
     constructor(node: AnyNode, scope: Context);
+    validate(validateChildren?: boolean): void;
     run(): unknown;
 }

package/cjs/helpers/kscript/nodes/TemplateLiteral.js

@@ -25,6 +25,14 @@ class TemplateLiteralNode extends Node_1.default {
     constructor(node, scope) {
         super(node, scope, 'TemplateLiteral');
     }
+    validate(validateChildren = false) {
+        if (!validateChildren) {
+            return;
+        }
+        for (const expression of this.node.expressions) {
+            (0, utils_1.construct)(expression, this.context).validate(true);
+        }
+    }
     run() {
         return this.node.quasis.reduce((acc, quasi, i) => {
             const expression = this.node.expressions[i] ? (0, utils_1.construct)(this.node.expressions[i], this.context).run() : '';

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

@@ -0,0 +1,8 @@
+import { AnyNode, VariableDeclaration } from 'acorn';
+import Context from '../Context';
+import Node from './Node';
+export default class VariableDeclarationNode extends Node<VariableDeclaration> {
+    constructor(node: AnyNode, context: Context);
+    validate(validateChildren?: boolean): void;
+    run(): void;
+}

package/cjs/helpers/kscript/nodes/VariableDeclaration.js

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Node_1 = __importDefault(require("./Node"));
+const utils_1 = require("../utils");
+class VariableDeclarationNode extends Node_1.default {
+    constructor(node, context) {
+        super(node, context, 'VariableDeclaration');
+    }
+    validate(validateChildren = false) {
+        if (this.node.kind === 'var') {
+            throw new Error('var is not supported. use let or const instead');
+        }
+        for (const declaration of this.node.declarations) {
+            if (declaration.id.type !== 'Identifier') {
+                throw new Error('variable name must be an identifier');
+            }
+        }
+        if (!validateChildren) {
+            return;
+        }
+        for (const declaration of this.node.declarations) {
+            (0, utils_1.construct)(declaration.id, this.context).validate(true);
+            if (declaration.init) {
+                (0, utils_1.construct)(declaration.init, this.context).validate(true);
+            }
+        }
+    }
+    run() {
+        this.validate();
+        for (const declaration of this.node.declarations) {
+            const id = declaration.id.name;
+            let init;
+            if (declaration.init) {
+                init = (0, utils_1.construct)(declaration.init, this.context).run();
+            }
+            this.context.declare(id, init, this.node.kind === 'const');
+        }
+    }
+}
+exports.default = VariableDeclarationNode;

package/cjs/helpers/kscript/nodes/expressions/ArrayExpression.d.ts

@@ -3,5 +3,6 @@ import type Context from '../../Context';
 import Node from '../Node';
 export default class ArrayExpressionNode extends Node<ArrayExpression> {
     constructor(node: AnyNode, context: Context);
+    validate(validateChildren?: boolean): void;
     run(): unknown;
 }

package/cjs/helpers/kscript/nodes/expressions/ArrayExpression.js

@@ -9,6 +9,17 @@ class ArrayExpressionNode extends Node_1.default {
     constructor(node, context) {
         super(node, context, 'ArrayExpression');
     }
+    validate(validateChildren = false) {
+        if (!validateChildren) {
+            return;
+        }
+        for (const element of this.node.elements) {
+            if (element === null) {
+                continue;
+            }
+            (0, utils_1.construct)(element, this.context).validate(true);
+        }
+    }
     run() {
         const array = [];
         for (const element of this.node.elements) {

package/cjs/helpers/kscript/nodes/expressions/ArrowFunctionExpression.d.ts

@@ -10,5 +10,6 @@ import Node from '../Node';
 export default class ArrowFunctionExpressionNode extends Node<ArrowFunctionExpression> {
     private readonly params;
     constructor(node: AnyNode, context: Context);
+    validate(validateChildren?: boolean): void;
     run(): unknown;
 }

package/cjs/helpers/kscript/nodes/expressions/ArrowFunctionExpression.js

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const Node_1 = __importDefault(require("../Node"));
+const ReturnStatement_1 = require("../statements/ReturnStatement");
 const utils_1 = require("../../utils");
 /** Represents an arrow function expression.
  *
@@ -19,21 +20,34 @@ class ArrowFunctionExpressionNode extends Node_1.default {
         }
         this.params = this.node.params;
     }
-    run() {
+    validate(validateChildren = false) {
         if (!this.context.isFunctionCallAllowed)
             throw new Error('functions are not allowed');
-        if (!this.node.expression)
-            throw new Error('functions must be an expression');
         if (this.node.async)
             throw new Error('async functions are not supported');
+        if (!validateChildren) {
+            return;
+        }
+        (0, utils_1.construct)(this.node.body, this.context).validate(true);
+    }
+    run() {
+        this.validate();
         return (...args) => {
             const scope = new Map();
             for (const param of this.params) {
                 const index = this.params.indexOf(param);
                 scope.set(param.name, args?.[index]);
             }
-            const newContext = this.context.newChildContext(scope);
-            return (0, utils_1.construct)(this.node.body, newContext).run();
+            const newContext = this.context.newChild(scope);
+            try {
+                return (0, utils_1.construct)(this.node.body, newContext).run();
+            }
+            catch (e) {
+                if (e instanceof ReturnStatement_1.ReturnStatementError) {
+                    return e.value;
+                }
+                throw e;
+            }
         };
     }
 }

package/cjs/helpers/kscript/nodes/expressions/AssignmentExpression.d.ts

@@ -0,0 +1,8 @@
+import { AnyNode, AssignmentExpression } from 'acorn';
+import Context from '../../Context';
+import Node from '../Node';
+export default class AssignmentExpressionNode extends Node<AssignmentExpression> {
+    constructor(node: AnyNode, context: Context);
+    validate(validateChildren?: boolean): void;
+    run(): unknown;
+}

package/cjs/helpers/kscript/nodes/expressions/AssignmentExpression.js

@@ -0,0 +1,33 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Node_1 = __importDefault(require("../Node"));
+const utils_1 = require("../../utils");
+class AssignmentExpressionNode extends Node_1.default {
+    constructor(node, context) {
+        super(node, context, 'AssignmentExpression');
+    }
+    validate(validateChildren = false) {
+        if (this.node.operator !== '=') {
+            throw new Error('Only = operator is supported');
+        }
+        if (this.node.left.type !== 'Identifier') {
+            throw new Error('Left side of assignment must be an identifier');
+        }
+        if (!validateChildren) {
+            return;
+        }
+        (0, utils_1.construct)(this.node.left, this.context).validate(true);
+        (0, utils_1.construct)(this.node.right, this.context).validate(true);
+    }
+    run() {
+        this.validate();
+        const identifier = this.node.left.name;
+        const right = (0, utils_1.construct)(this.node.right, this.context).run();
+        this.context.set(identifier, right);
+        return right;
+    }
+}
+exports.default = AssignmentExpressionNode;

package/cjs/helpers/kscript/nodes/expressions/BinaryExpression.d.ts

@@ -6,9 +6,17 @@ import Node from '../Node';
  * e.g. `1 + 2`, `a === b`, `c < d`
  */
 export default class BinaryExpressionNode extends Node<BinaryExpression> {
+    private static readonly EQUALITY_OPERATORS;
+    private static readonly COMPARISON_OPERATORS;
+    private static readonly ARITHMETIC_OPERATORS;
+    private static readonly BITWISE_OPERATORS;
+    private static readonly IN_OPERATOR;
+    private static readonly SUPPORTED_OPERATORS;
     constructor(node: AnyNode, context: Context);
+    validate(validateChildren?: boolean): void;
     run(): unknown;
     private operate;
+    private bitwise;
     private arithmetic;
     private comparison;
     private equality;