@dronedeploy/rocos-js-sdk 3.0.11 → 3.0.13

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

@@ -1,4 +1,5 @@
 import Node from '../Node';
+import { ReturnStatementError } from '../statements/ReturnStatement';
 import { construct } from '../../utils';
 /** Represents an arrow function expression.
  *
@@ -17,8 +18,6 @@ export default class ArrowFunctionExpressionNode extends Node {
     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) {
@@ -34,8 +33,16 @@ export default class ArrowFunctionExpressionNode extends Node {
                 const index = this.params.indexOf(param);
                 scope.set(param.name, args?.[index]);
             }
-            const newContext = this.context.newChildContext(scope);
-            return construct(this.node.body, newContext).run();
+            const newContext = this.context.newChild(scope);
+            try {
+                return construct(this.node.body, newContext).run();
+            }
+            catch (e) {
+                if (e instanceof ReturnStatementError) {
+                    return e.value;
+                }
+                throw e;
+            }
         };
     }
 }

package/esm/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/esm/helpers/kscript/nodes/expressions/AssignmentExpression.js

@@ -0,0 +1,27 @@
+import Node from '../Node';
+import { construct } from '../../utils';
+export default class AssignmentExpressionNode extends Node {
+    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;
+        }
+        construct(this.node.left, this.context).validate(true);
+        construct(this.node.right, this.context).validate(true);
+    }
+    run() {
+        this.validate();
+        const identifier = this.node.left.name;
+        const right = construct(this.node.right, this.context).run();
+        this.context.set(identifier, right);
+        return right;
+    }
+}

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

@@ -9,12 +9,14 @@ 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;

package/esm/helpers/kscript/nodes/expressions/BinaryExpression.js

@@ -33,11 +33,25 @@ class BinaryExpressionNode extends Node {
         if (BinaryExpressionNode.ARITHMETIC_OPERATORS.has(this.node.operator)) {
             return this.arithmetic(this.node.operator, left, right);
         }
+        if (BinaryExpressionNode.BITWISE_OPERATORS.has(this.node.operator)) {
+            return this.bitwise(this.node.operator, left, right);
+        }
         if (this.node.operator === BinaryExpressionNode.IN_OPERATOR) {
             return this.checkIn(left, right);
         }
         throw new Error(`Unsupported operator: ${this.node.operator}`);
     }
+    bitwise(operator, left, right) {
+        if (typeof left !== 'number' || typeof right !== 'number') {
+            throw new Error('Bitwise operators are only supported for numbers');
+        }
+        switch (operator) {
+            case '<<':
+                return left << right;
+            case '>>':
+                return left >> right;
+        }
+    }
     arithmetic(operator, left, right) {
         if (operator === '+' && (typeof left === 'string' || typeof right === 'string')) {
             return `${left}${right}`;
@@ -106,11 +120,13 @@ BinaryExpressionNode.ARITHMETIC_OPERATORS = new Set([
     '%',
     '**',
 ]);
+BinaryExpressionNode.BITWISE_OPERATORS = new Set(['<<', '>>']);
 BinaryExpressionNode.IN_OPERATOR = 'in';
 BinaryExpressionNode.SUPPORTED_OPERATORS = new Set([
     ...BinaryExpressionNode.EQUALITY_OPERATORS,
     ...BinaryExpressionNode.COMPARISON_OPERATORS,
     ...BinaryExpressionNode.ARITHMETIC_OPERATORS,
+    ...BinaryExpressionNode.BITWISE_OPERATORS,
     BinaryExpressionNode.IN_OPERATOR,
 ]);
 export default BinaryExpressionNode;

package/esm/helpers/kscript/nodes/expressions/LogicalExpression.js

@@ -29,7 +29,7 @@ class BinaryExpressionNode extends Node {
             return false;
         }
         if (this.node.operator === '||' && left) {
-            return true;
+            return left;
         }
         if (this.node.operator === '??' && left !== null && left !== undefined) {
             return left;

package/esm/helpers/kscript/nodes/expressions/NewExpression.d.ts

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

package/esm/helpers/kscript/nodes/expressions/NewExpression.js

@@ -0,0 +1,38 @@
+import Node from '../Node';
+import { construct } from '../../utils';
+export default class NewExpressionNode extends Node {
+    constructor(node, context) {
+        super(node, context, 'NewExpression');
+    }
+    validate(validateChildren = false) {
+        if (!this.context.isFunctionCallAllowed)
+            throw new Error('Constructors are not allowed');
+        if (!validateChildren) {
+            return;
+        }
+        construct(this.node.callee, this.context).validate(true);
+        for (const arg of this.node.arguments) {
+            construct(arg, this.context).validate(true);
+        }
+    }
+    run() {
+        this.validate();
+        const callee = construct(this.node.callee, this.context).run();
+        if (typeof callee !== 'function') {
+            throw new Error('callee is not a function');
+        }
+        const args = this.spreadArgs(this.node.arguments);
+        return new (Function.prototype.bind.apply(callee, [null, ...args]))();
+    }
+    spreadArgs(args) {
+        return args.reduce((acc, arg) => {
+            if (arg.type === 'SpreadElement') {
+                acc.push(...construct(arg.argument, this.context).run());
+            }
+            else {
+                acc.push(construct(arg, this.context).run());
+            }
+            return acc;
+        }, []);
+    }
+}

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

@@ -1,4 +1,3 @@
-export { default as ExpressionStatement } from './ExpressionStatement';
 export { default as ArrayExpression } from './ArrayExpression';
 export { default as ObjectExpression } from './ObjectExpression';
 export { default as BinaryExpression } from './BinaryExpression';
@@ -9,3 +8,5 @@ export { default as CallExpression } from './CallExpression';
 export { default as ArrowFunctionExpression } from './ArrowFunctionExpression';
 export { default as MemberExpression } from './MemberExpression';
 export { default as ChainExpression } from './ChainExpression';
+export { default as NewExpression } from './NewExpression';
+export { default as AssignmentExpression } from './AssignmentExpression';

package/esm/helpers/kscript/nodes/expressions/index.js

@@ -1,4 +1,3 @@
-export { default as ExpressionStatement } from './ExpressionStatement';
 export { default as ArrayExpression } from './ArrayExpression';
 export { default as ObjectExpression } from './ObjectExpression';
 export { default as BinaryExpression } from './BinaryExpression';
@@ -9,3 +8,5 @@ export { default as CallExpression } from './CallExpression';
 export { default as ArrowFunctionExpression } from './ArrowFunctionExpression';
 export { default as MemberExpression } from './MemberExpression';
 export { default as ChainExpression } from './ChainExpression';
+export { default as NewExpression } from './NewExpression';
+export { default as AssignmentExpression } from './AssignmentExpression';

package/esm/helpers/kscript/nodes/nodeTypes.d.ts

@@ -1,4 +1,5 @@
-import { ArrayExpression, ArrowFunctionExpression, BinaryExpression, CallExpression, ChainExpression, ConditionalExpression, ExpressionStatement, LogicalExpression, MemberExpression, ObjectExpression, UnaryExpression } from './expressions';
+import { ArrayExpression, ArrowFunctionExpression, AssignmentExpression, BinaryExpression, CallExpression, ChainExpression, ConditionalExpression, LogicalExpression, MemberExpression, NewExpression, ObjectExpression, UnaryExpression } from './expressions';
+import { BlockStatement, ExpressionStatement, ReturnStatement, SwitchStatement } from './statements';
 import { AnyNode } from 'acorn';
 import type Context from '../Context';
 import Identifier from './Identifier';
@@ -6,6 +7,7 @@ import Literal from './Literal';
 import Node from './Node';
 import Program from './Program';
 import TemplateLiteral from './TemplateLiteral';
+import VariableDeclaration from './VariableDeclaration';
 type NodeConstructor = {
     new (node: AnyNode, scope: Context): Node<AnyNode>;
 };
@@ -27,6 +29,12 @@ declare const nodes: {
     readonly CallExpression: typeof CallExpression;
     readonly MemberExpression: typeof MemberExpression;
     readonly ChainExpression: typeof ChainExpression;
+    readonly NewExpression: typeof NewExpression;
+    readonly BlockStatement: typeof BlockStatement;
+    readonly ReturnStatement: typeof ReturnStatement;
+    readonly VariableDeclaration: typeof VariableDeclaration;
+    readonly AssignmentExpression: typeof AssignmentExpression;
+    readonly SwitchStatement: typeof SwitchStatement;
 };
 export type NodeType = keyof typeof nodes;
 declare const _default: NodeMap;

package/esm/helpers/kscript/nodes/nodeTypes.js

@@ -1,8 +1,10 @@
-import { ArrayExpression, ArrowFunctionExpression, BinaryExpression, CallExpression, ChainExpression, ConditionalExpression, ExpressionStatement, LogicalExpression, MemberExpression, ObjectExpression, UnaryExpression, } from './expressions';
+import { ArrayExpression, ArrowFunctionExpression, AssignmentExpression, BinaryExpression, CallExpression, ChainExpression, ConditionalExpression, LogicalExpression, MemberExpression, NewExpression, ObjectExpression, UnaryExpression, } from './expressions';
+import { BlockStatement, ExpressionStatement, ReturnStatement, SwitchStatement } from './statements';
 import Identifier from './Identifier';
 import Literal from './Literal';
 import Program from './Program';
 import TemplateLiteral from './TemplateLiteral';
+import VariableDeclaration from './VariableDeclaration';
 const nodes = {
     Program,
     Literal,
@@ -20,5 +22,11 @@ const nodes = {
     CallExpression,
     MemberExpression,
     ChainExpression,
+    NewExpression,
+    BlockStatement,
+    ReturnStatement,
+    VariableDeclaration,
+    AssignmentExpression,
+    SwitchStatement,
 };
 export default new Map(Object.entries(nodes));

package/esm/helpers/kscript/nodes/statements/BlockStatement.d.ts

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

package/esm/helpers/kscript/nodes/statements/BlockStatement.js

@@ -0,0 +1,23 @@
+import Node from '../Node';
+import { construct } from '../../utils';
+export default class BlockStatementNode extends Node {
+    constructor(node, context) {
+        super(node, context.newChild(), 'BlockStatement');
+    }
+    validate(validateChildren = false) {
+        if (!validateChildren) {
+            return;
+        }
+        for (const statement of this.node.body) {
+            construct(statement, this.context).validate(true);
+        }
+    }
+    run() {
+        this.validate();
+        let result;
+        for (const statement of this.node.body) {
+            result = construct(statement, this.context).run();
+        }
+        return result;
+    }
+}

package/esm/helpers/kscript/nodes/statements/ReturnStatement.d.ts

@@ -0,0 +1,12 @@
+import { AnyNode, ReturnStatement } from 'acorn';
+import type Context from '../../Context';
+import Node from '../Node';
+export declare class ReturnStatementError extends Error {
+    readonly value: unknown;
+    constructor(value: unknown);
+}
+export default class ReturnStatementNode extends Node<ReturnStatement> {
+    constructor(node: AnyNode, context: Context);
+    validate(validateChildren?: boolean): void;
+    run(): unknown;
+}

package/esm/helpers/kscript/nodes/statements/ReturnStatement.js

@@ -0,0 +1,25 @@
+import Node from '../Node';
+import { construct } from '../../utils';
+export class ReturnStatementError extends Error {
+    constructor(value) {
+        super('Illegal return statement');
+        this.value = value;
+    }
+}
+export default class ReturnStatementNode extends Node {
+    constructor(node, context) {
+        super(node, context, 'ReturnStatement');
+    }
+    validate(validateChildren = false) {
+        const arg = this.node.argument;
+        if (!validateChildren || arg === undefined || arg === null) {
+            return;
+        }
+        construct(arg, this.context).validate(true);
+    }
+    run() {
+        this.validate();
+        const result = this.node.argument ? construct(this.node.argument, this.context).run() : undefined;
+        throw new ReturnStatementError(result);
+    }
+}

package/esm/helpers/kscript/nodes/statements/SwitchStatement.d.ts

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

package/esm/helpers/kscript/nodes/statements/SwitchStatement.js

@@ -0,0 +1,46 @@
+import Node from '../Node';
+import { construct } from '../../utils';
+export default class SwitchStatementNode extends Node {
+    constructor(node, context) {
+        super(node, context, 'SwitchStatement');
+    }
+    test_match(test, discriminant) {
+        if (!test) {
+            return true;
+        }
+        const testValue = construct(test, this.context).run();
+        return testValue === discriminant;
+    }
+    validate(validateChildren = false) {
+        if (!validateChildren) {
+            return;
+        }
+        construct(this.node.discriminant, this.context).validate(true);
+        for (const c of this.node.cases) {
+            if (c.test) {
+                construct(c.test, this.context).validate(true);
+            }
+            for (const s of c.consequent) {
+                construct(s, this.context).validate(true);
+            }
+        }
+    }
+    run() {
+        this.validate();
+        const discriminant = construct(this.node.discriminant, this.context).run();
+        let result;
+        let matched = false;
+        for (const c of this.node.cases) {
+            if (!matched && this.test_match(c.test, discriminant)) {
+                matched = true;
+            }
+            if (!matched) {
+                continue;
+            }
+            for (const s of c.consequent) {
+                result = construct(s, this.context).run();
+            }
+        }
+        return result;
+    }
+}

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

@@ -0,0 +1,4 @@
+export { default as BlockStatement } from './BlockStatement';
+export { default as ReturnStatement } from './ReturnStatement';
+export { default as ExpressionStatement } from './ExpressionStatement';
+export { default as SwitchStatement } from './SwitchStatement';

package/esm/helpers/kscript/nodes/statements/index.js

@@ -0,0 +1,4 @@
+export { default as BlockStatement } from './BlockStatement';
+export { default as ReturnStatement } from './ReturnStatement';
+export { default as ExpressionStatement } from './ExpressionStatement';
+export { default as SwitchStatement } from './SwitchStatement';

package/esm/services/BaseStreamService.js

@@ -41,7 +41,7 @@ export class BaseStreamService {
                 this.status = msg === SubscriberStatusEnum.STOPPED || msg === SubscriberStatusEnum.ALIVE;
                 this.status$.next(msg);
             });
-            await streamRegister.addStream(stream);
+            streamRegister.addStream(stream);
             await this.initStream(stream);
         }
         return { stream, isNew };

package/esm/services/WebRTCSignallingService.js

@@ -50,8 +50,7 @@ export class WebRTCSignallingService {
                 this.status = msg === SubscriberStatusEnum.STOPPED || msg === SubscriberStatusEnum.ALIVE;
                 this.status$.next(msg);
             });
-            // don't wait for these promises, they can be init after startup
-            await streamRegister.addStream(stream);
+            streamRegister.addStream(stream);
             await this.initStream(stream);
         }
         return stream;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dronedeploy/rocos-js-sdk",
-  "version": "3.0.11",
+  "version": "3.0.13",
   "description": "Javascript SDK for rocos",
   "main": "cjs/index.js",
   "module": "esm/index.js",