@dronedeploy/rocos-js-sdk 3.0.1-alpha.20 → 3.0.1-alpha.22

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

@@ -0,0 +1,8 @@
+import { AnyNode, CallExpression } from 'acorn';
+import Context from '../../Context';
+import Node from '../Node';
+export default class CallExpressionNode extends Node<CallExpression> {
+    constructor(node: AnyNode, context: Context);
+    run(): unknown;
+    private spreadArgs;
+}

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

@@ -0,0 +1,32 @@
+import Node from '../Node';
+import { construct } from '../../utils';
+export default class CallExpressionNode extends Node {
+    constructor(node, context) {
+        super(node, context, 'CallExpression');
+    }
+    run() {
+        if (!this.context.isFunctionCallAllowed)
+            throw new Error('Function calls are not allowed');
+        const callee = construct(this.node.callee, this.context).run();
+        let thisArg = {};
+        if (this.node.callee.type === 'MemberExpression') {
+            thisArg = construct(this.node.callee.object, this.context).run();
+        }
+        if (typeof callee !== 'function') {
+            throw new Error('callee is not a function');
+        }
+        const args = this.spreadArgs(this.node.arguments);
+        return callee.call(thisArg, ...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/ChainExpression.d.ts

@@ -0,0 +1,16 @@
+import { AnyNode, ChainExpression } from 'acorn';
+import Context from '../../Context';
+import Node from '../Node';
+/**
+ * A ChainExpression node is created when the chain operator is used.
+ *
+ * e.g. `a?.b?.c`
+ *
+ * This node does not need to do anything special, as the chain operator is handled by the MemberExpressionNode.
+ *
+ * @see MemberExpressionNode
+ */
+export default class ExpressionStatementNode extends Node<ChainExpression> {
+    constructor(node: AnyNode, context: Context);
+    run(): unknown;
+}

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

@@ -0,0 +1,19 @@
+import Node from '../Node';
+import { construct } from '../../utils';
+/**
+ * A ChainExpression node is created when the chain operator is used.
+ *
+ * e.g. `a?.b?.c`
+ *
+ * This node does not need to do anything special, as the chain operator is handled by the MemberExpressionNode.
+ *
+ * @see MemberExpressionNode
+ */
+export default class ExpressionStatementNode extends Node {
+    constructor(node, context) {
+        super(node, context, 'ChainExpression');
+    }
+    run() {
+        return construct(this.node.expression, this.context).run();
+    }
+}

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

@@ -0,0 +1,14 @@
+import { AnyNode, ConditionalExpression, IfStatement } from 'acorn';
+import type Context from '../../Context';
+import Node from '../Node';
+/** Represents a ternary conditional expression (a ? b : c) or an if statement (if (a) b else c).
+ *
+ * If a (test) is truthy, b (consequent) is returned. Otherwise, c (alternate) is returned.
+ *
+ * Since the if statement and the conditional expression are so similar, they are both handled by this node,
+ * even though they are separate in the AST.
+ */
+export default class ConditionalExpressionNode extends Node<IfStatement | ConditionalExpression> {
+    constructor(node: AnyNode, context: Context);
+    run(): unknown;
+}

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

@@ -0,0 +1,24 @@
+import Node from '../Node';
+import { construct } from '../../utils';
+/** Represents a ternary conditional expression (a ? b : c) or an if statement (if (a) b else c).
+ *
+ * If a (test) is truthy, b (consequent) is returned. Otherwise, c (alternate) is returned.
+ *
+ * Since the if statement and the conditional expression are so similar, they are both handled by this node,
+ * even though they are separate in the AST.
+ */
+export default class ConditionalExpressionNode extends Node {
+    constructor(node, context) {
+        super(node, context, ['ConditionalExpression', 'IfStatement']);
+    }
+    run() {
+        const test = construct(this.node.test, this.context).run();
+        if (test) {
+            return construct(this.node.consequent, this.context).run();
+        }
+        if (this.node.alternate === null || this.node.alternate === undefined) {
+            return undefined;
+        }
+        return construct(this.node.alternate, this.context).run();
+    }
+}

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

@@ -0,0 +1,7 @@
+import { AnyNode, ExpressionStatement } from 'acorn';
+import Context from '../../Context';
+import Node from '../Node';
+export default class ExpressionStatementNode extends Node<ExpressionStatement> {
+    constructor(node: AnyNode, context: Context);
+    run(): unknown;
+}

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

@@ -0,0 +1,12 @@
+import Node from '../Node';
+import { construct } from '../../utils';
+export default class ExpressionStatementNode extends Node {
+    constructor(node, context) {
+        super(node, context, 'ExpressionStatement');
+    }
+    run() {
+        if (this.node.directive)
+            throw new Error('Directives are not supported');
+        return construct(this.node.expression, this.context).run();
+    }
+}

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

@@ -0,0 +1,10 @@
+import { AnyNode, LogicalExpression } from 'acorn';
+import Context from '../../Context';
+import Node from '../Node';
+export default class BinaryExpressionNode extends Node<LogicalExpression> {
+    constructor(node: AnyNode, context: Context);
+    run(): unknown;
+    /** Try and skip evaluating the right operand */
+    private shortCircuit;
+    private operate;
+}

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

@@ -0,0 +1,41 @@
+import Node from '../Node';
+import { construct } from '../../utils';
+export default class BinaryExpressionNode extends Node {
+    constructor(node, context) {
+        super(node, context, 'LogicalExpression');
+    }
+    run() {
+        const left = construct(this.node.left, this.context).run();
+        const shortCircuit = this.shortCircuit(left);
+        if (shortCircuit !== null) {
+            return shortCircuit;
+        }
+        const right = construct(this.node.right, this.context).run();
+        return this.operate(left, right);
+    }
+    /** Try and skip evaluating the right operand */
+    shortCircuit(left) {
+        if (this.node.operator === '&&' && !left) {
+            return false;
+        }
+        if (this.node.operator === '||' && left) {
+            return true;
+        }
+        if (this.node.operator === '??' && left !== null && left !== undefined) {
+            return left;
+        }
+        return null;
+    }
+    operate(left, right) {
+        switch (this.node.operator) {
+            case '||':
+                return left || right;
+            case '&&':
+                return left && right;
+            case '??':
+                return left ?? right;
+            default:
+                throw new Error(`Unsupported operator: ${this.node.operator}`);
+        }
+    }
+}

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

@@ -0,0 +1,44 @@
+import { AnyNode, MemberExpression } from 'acorn';
+import Context from '../../Context';
+import Node from '../Node';
+/**
+ * A member expression is an expression that accesses a property of an object.
+ *
+ * Examples of member expressions are:
+ *  - `a.b`
+ *  - `a['b']`
+ *  - `a[0]`
+ *  - `a?.b`
+ *  - `a?.['b']`
+ *  - `a?.[0]`
+ *
+ *  A member access in the sandbox is considered secure if the following conditions are met:
+ *    - The property is not named 'constructor'
+ *    - Either:
+ *      * The property is owned by the object and is *not* on the whitelist.
+ *      * The prototype is whitelisted and the property list is null or contains the property.
+ *
+ *  @see Context.isPrototypeAllowed
+ */
+export default class MemberExpressionNode extends Node<MemberExpression> {
+    constructor(node: AnyNode, context: Context);
+    run(): unknown;
+    /** Returns the name of the property being accessed.
+     *
+     * Handles both computed and non-computed properties.
+     */
+    private getPropertyIdentifier;
+    /** Checks if the property can be accessed on the object.
+     *
+     * @throws {Error} If the property is not allowed to be accessed.
+     */
+    private checkPropertyAccess;
+    /** Searches the prototype chain of the object for the prototype that defines the property. */
+    private getPropertyPrototype;
+    /**
+     * Returns true if the property exists on the object.
+     *
+     * i.e. the property is defined somewhere on the prototype chain.
+     */
+    private propertyExists;
+}

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

@@ -0,0 +1,92 @@
+import Node from '../Node';
+import { construct } from '../../utils';
+/**
+ * A member expression is an expression that accesses a property of an object.
+ *
+ * Examples of member expressions are:
+ *  - `a.b`
+ *  - `a['b']`
+ *  - `a[0]`
+ *  - `a?.b`
+ *  - `a?.['b']`
+ *  - `a?.[0]`
+ *
+ *  A member access in the sandbox is considered secure if the following conditions are met:
+ *    - The property is not named 'constructor'
+ *    - Either:
+ *      * The property is owned by the object and is *not* on the whitelist.
+ *      * The prototype is whitelisted and the property list is null or contains the property.
+ *
+ *  @see Context.isPrototypeAllowed
+ */
+export default class MemberExpressionNode extends Node {
+    constructor(node, context) {
+        super(node, context, 'MemberExpression');
+    }
+    run() {
+        const object = construct(this.node.object, this.context).run();
+        if (object === null || object === undefined) {
+            if (this.node.optional)
+                return undefined;
+            throw new Error(`Cannot read property of ${object}`);
+        }
+        const propertyIdentifier = this.getPropertyIdentifier();
+        if (!this.propertyExists(object, propertyIdentifier)) {
+            return undefined;
+        }
+        this.checkPropertyAccess(object, propertyIdentifier);
+        return object[propertyIdentifier];
+    }
+    /** Returns the name of the property being accessed.
+     *
+     * Handles both computed and non-computed properties.
+     */
+    getPropertyIdentifier() {
+        if (this.node.computed) {
+            const name = construct(this.node.property, this.context).run();
+            if (typeof name !== 'string' && typeof name !== 'number') {
+                throw new Error('Only string or number computed properties are supported');
+            }
+            return name;
+        }
+        if (this.node.property.type !== 'Identifier') {
+            throw new Error('Only identifiers are supported for non-computed member expression properties');
+        }
+        return this.node.property.name;
+    }
+    /** Checks if the property can be accessed on the object.
+     *
+     * @throws {Error} If the property is not allowed to be accessed.
+     */
+    checkPropertyAccess(object, propertyIdentifier) {
+        if (typeof propertyIdentifier === 'number')
+            return;
+        if (propertyIdentifier === 'constructor') {
+            throw new Error('Cannot access constructor property');
+        }
+        const definingProto = this.getPropertyPrototype(object, propertyIdentifier);
+        const ownProperty = Object.prototype.hasOwnProperty.call(object, propertyIdentifier);
+        if (!this.context.isPrototypeAllowed(definingProto, propertyIdentifier, ownProperty)) {
+            throw new Error(`SecurityError: Access to property '${propertyIdentifier}' is not allowed`);
+        }
+    }
+    /** Searches the prototype chain of the object for the prototype that defines the property. */
+    getPropertyPrototype(object, propertyIdentifier) {
+        let proto = object;
+        while (proto !== null) {
+            if (Object.prototype.hasOwnProperty.call(proto, propertyIdentifier)) {
+                return proto;
+            }
+            proto = Object.getPrototypeOf(proto);
+        }
+        return null;
+    }
+    /**
+     * Returns true if the property exists on the object.
+     *
+     * i.e. the property is defined somewhere on the prototype chain.
+     */
+    propertyExists(object, propertyIdentifier) {
+        return this.getPropertyPrototype(object, propertyIdentifier) !== null;
+    }
+}

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

@@ -0,0 +1,11 @@
+import { AnyNode, ObjectExpression } from 'acorn';
+import type Context from '../../Context';
+import Node from '../Node';
+export default class ObjectExpressionNode extends Node<ObjectExpression> {
+    constructor(node: AnyNode, context: Context);
+    run(): unknown;
+    private addProperty;
+    private spreadProperty;
+    private getKey;
+    private getStaticKey;
+}

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

@@ -0,0 +1,53 @@
+import Node from '../Node';
+import { construct } from '../../utils';
+export default class ObjectExpressionNode extends Node {
+    constructor(node, context) {
+        super(node, context, 'ObjectExpression');
+    }
+    run() {
+        const object = {};
+        for (const property of this.node.properties) {
+            if (property.type === 'SpreadElement') {
+                this.spreadProperty(property, object);
+                continue;
+            }
+            this.addProperty(property, object);
+        }
+        return object;
+    }
+    addProperty(property, object) {
+        if (property.kind !== 'init')
+            throw new Error('Only init properties are supported');
+        const key = this.getKey(property);
+        object[key] = construct(property.value, this.context).run();
+    }
+    spreadProperty(property, object) {
+        const value = construct(property.argument, this.context).run();
+        if (!(typeof value === 'object' && value !== null)) {
+            throw new Error('Spread argument must be an object');
+        }
+        Object.assign(object, value);
+    }
+    getKey(property) {
+        let key;
+        if (property.computed) {
+            key = construct(property.key, this.context).run();
+        }
+        else {
+            key = this.getStaticKey(property.key);
+        }
+        if (key === null || key === undefined)
+            throw new Error('Key cannot be null or undefined');
+        if (typeof key !== 'string' && typeof key !== 'number' && typeof key !== 'symbol') {
+            throw new Error(`Unsupported key type: ${typeof key}`);
+        }
+        return key;
+    }
+    getStaticKey(key) {
+        if (key.type === 'Identifier')
+            return key.name;
+        if (key.type === 'Literal')
+            return key.value;
+        throw new Error('Only identifier and literal keys are supported');
+    }
+}

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

@@ -0,0 +1,12 @@
+import { AnyNode, UnaryExpression } from 'acorn';
+import Context from '../../Context';
+import Node from '../Node';
+/** A unary expression is an expression that consists of a single operand and an operator
+ *
+ * e.g. `+1`, `-2`, `!true`, `typeof x`
+ */
+export default class UnaryExpressionNode extends Node<UnaryExpression> {
+    constructor(node: AnyNode, context: Context);
+    run(): unknown;
+    private arithmetic;
+}

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

@@ -0,0 +1,38 @@
+import Node from '../Node';
+import { construct } from '../../utils';
+/** A unary expression is an expression that consists of a single operand and an operator
+ *
+ * e.g. `+1`, `-2`, `!true`, `typeof x`
+ */
+export default class UnaryExpressionNode extends Node {
+    constructor(node, context) {
+        super(node, context, 'UnaryExpression');
+    }
+    run() {
+        const argument = construct(this.node.argument, this.context).run();
+        switch (this.node.operator) {
+            case '+':
+            case '-':
+                return this.arithmetic(this.node.operator, argument);
+            case '!':
+                return !argument;
+            case 'typeof':
+                return typeof argument;
+            default:
+                throw new Error(`Unsupported operator: ${this.node.operator}`);
+        }
+    }
+    arithmetic(operator, argument) {
+        if (typeof argument !== 'number') {
+            throw new Error('Unary arithmetic operators are only supported for numbers');
+        }
+        switch (operator) {
+            case '+':
+                return +argument;
+            case '-':
+                return -argument;
+            default:
+                throw new Error(`Unsupported operator: ${operator}`);
+        }
+    }
+}

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

@@ -0,0 +1,11 @@
+export { default as ExpressionStatement } from './ExpressionStatement';
+export { default as ArrayExpression } from './ArrayExpression';
+export { default as ObjectExpression } from './ObjectExpression';
+export { default as BinaryExpression } from './BinaryExpression';
+export { default as UnaryExpression } from './UnaryExpression';
+export { default as LogicalExpression } from './LogicalExpression';
+export { default as ConditionalExpression } from './ConditionalExpression';
+export { default as CallExpression } from './CallExpression';
+export { default as ArrowFunctionExpression } from './ArrowFunctionExpression';
+export { default as MemberExpression } from './MemberExpression';
+export { default as ChainExpression } from './ChainExpression';

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

@@ -0,0 +1,11 @@
+export { default as ExpressionStatement } from './ExpressionStatement';
+export { default as ArrayExpression } from './ArrayExpression';
+export { default as ObjectExpression } from './ObjectExpression';
+export { default as BinaryExpression } from './BinaryExpression';
+export { default as UnaryExpression } from './UnaryExpression';
+export { default as LogicalExpression } from './LogicalExpression';
+export { default as ConditionalExpression } from './ConditionalExpression';
+export { default as CallExpression } from './CallExpression';
+export { default as ArrowFunctionExpression } from './ArrowFunctionExpression';
+export { default as MemberExpression } from './MemberExpression';
+export { default as ChainExpression } from './ChainExpression';

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

@@ -0,0 +1,4 @@
+import { NodeType, default as nodes } from './nodeTypes';
+import Context from '../Context';
+import Node from './Node';
+export { type Node, type NodeType, nodes, Context };

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

@@ -0,0 +1,3 @@
+import { default as nodes } from './nodeTypes';
+import Context from '../Context';
+export { nodes, Context };

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

@@ -0,0 +1,33 @@
+import { ArrayExpression, ArrowFunctionExpression, BinaryExpression, CallExpression, ChainExpression, ConditionalExpression, ExpressionStatement, LogicalExpression, MemberExpression, ObjectExpression, UnaryExpression } from './expressions';
+import { AnyNode } from 'acorn';
+import type Context from '../Context';
+import Identifier from './Identifier';
+import Literal from './Literal';
+import Node from './Node';
+import Program from './Program';
+import TemplateLiteral from './TemplateLiteral';
+type NodeConstructor = {
+    new (node: AnyNode, scope: Context): Node<AnyNode>;
+};
+export type NodeMap = Map<AnyNode['type'], NodeConstructor>;
+declare const nodes: {
+    readonly Program: typeof Program;
+    readonly Literal: typeof Literal;
+    readonly ExpressionStatement: typeof ExpressionStatement;
+    readonly ArrayExpression: typeof ArrayExpression;
+    readonly ObjectExpression: typeof ObjectExpression;
+    readonly Identifier: typeof Identifier;
+    readonly BinaryExpression: typeof BinaryExpression;
+    readonly UnaryExpression: typeof UnaryExpression;
+    readonly LogicalExpression: typeof LogicalExpression;
+    readonly ConditionalExpression: typeof ConditionalExpression;
+    readonly IfStatement: typeof ConditionalExpression;
+    readonly TemplateLiteral: typeof TemplateLiteral;
+    readonly ArrowFunctionExpression: typeof ArrowFunctionExpression;
+    readonly CallExpression: typeof CallExpression;
+    readonly MemberExpression: typeof MemberExpression;
+    readonly ChainExpression: typeof ChainExpression;
+};
+export type NodeType = keyof typeof nodes;
+declare const _default: NodeMap;
+export default _default;

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

@@ -0,0 +1,24 @@
+import { ArrayExpression, ArrowFunctionExpression, BinaryExpression, CallExpression, ChainExpression, ConditionalExpression, ExpressionStatement, LogicalExpression, MemberExpression, ObjectExpression, UnaryExpression, } from './expressions';
+import Identifier from './Identifier';
+import Literal from './Literal';
+import Program from './Program';
+import TemplateLiteral from './TemplateLiteral';
+const nodes = {
+    Program,
+    Literal,
+    ExpressionStatement,
+    ArrayExpression,
+    ObjectExpression,
+    Identifier,
+    BinaryExpression,
+    UnaryExpression,
+    LogicalExpression,
+    ConditionalExpression,
+    IfStatement: ConditionalExpression,
+    TemplateLiteral,
+    ArrowFunctionExpression,
+    CallExpression,
+    MemberExpression,
+    ChainExpression,
+};
+export default new Map(Object.entries(nodes));

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

@@ -0,0 +1,4 @@
+import { Node } from './nodes';
+import { AnyNode } from 'acorn';
+import Context from './Context';
+export declare function construct(node: AnyNode, context: Context): Node<AnyNode>;

package/esm/helpers/kscript/utils.js

@@ -0,0 +1,11 @@
+import { nodes } from './nodes';
+export function construct(node, context) {
+    if (!context.isNodeAllowed(node.type)) {
+        throw new Error(`Blacklisted Operation: ${node.type}`);
+    }
+    const nodeClass = nodes.get(node.type);
+    if (!nodeClass) {
+        throw new Error(`Unknown node type: ${node.type}`);
+    }
+    return Reflect.construct(nodeClass, [node, context]);
+}

package/esm/services/AuthService.d.ts

@@ -1,5 +1,5 @@
-import { IBaseService, IRocosSDKConfig, RocosError, Token } from '../models';
 import { Observable } from 'rxjs';
+import { IBaseService, IRocosSDKConfig, RocosError, Token } from '../models';
 import { BaseServiceAbstract } from './BaseServiceAbstract';
 export declare class AuthService extends BaseServiceAbstract implements IBaseService {
     protected config: IRocosSDKConfig;
@@ -12,9 +12,9 @@ export declare class AuthService extends BaseServiceAbstract implements IBaseSer
      * This is useful for getting notified when the token changes.
      * i.e. when the token is refreshed from the token refresh checker.
      *
-     * This will not emit until the token is set, either by `setToken` or by getting a new token.
+     * It will emit the current token when you subscribe and then emit new tokens when they are set.
      */
-    get tokenUpdates$(): Observable<Token>;
+    get token$(): Observable<Token>;
     getStatus(): boolean;
     teardown(): void;
     protected getError(e: RocosError): RocosError;

package/esm/services/AuthService.js

@@ -1,22 +1,23 @@
 import { API_APPLICATION_AUTH_URL, API_OTP_AUTH_URL, API_OTP_URL, API_USER_TOKEN_URL } from '../constants/api';
+import { BehaviorSubject } from 'rxjs';
 import { RocosError, Token, errorCodes } from '../models';
-import { Subject } from 'rxjs';
 import { BaseServiceAbstract } from './BaseServiceAbstract';
 import { RocosLogger } from '../logger/RocosLogger';
 import { RocosStore } from '../store/RocosStore';
+import { filter } from 'rxjs/operators';
 import { formatServiceUrl } from '../helpers/formatServiceUrl';
 import { issuer } from '../constants/auth';
 export class AuthService extends BaseServiceAbstract {
     constructor(config) {
         super(config);
         this.config = config;
-        this.tokenSubject$ = new Subject();
+        this.tokenSubject$ = new BehaviorSubject(null);
         this.config = config;
         this.logger = RocosLogger.getInstance(`AuthService(${this.config.url})`);
         if (this.config.token) {
             this.setToken(this.config.token);
         }
-        this.tokenUpdates$.subscribe((token) => {
+        this.token$.subscribe((token) => {
             RocosStore.getChangeSubject().next({ type: 'token', url: this.config.url, data: token.value });
         });
     }
@@ -25,10 +26,10 @@ export class AuthService extends BaseServiceAbstract {
      * This is useful for getting notified when the token changes.
      * i.e. when the token is refreshed from the token refresh checker.
      *
-     * This will not emit until the token is set, either by `setToken` or by getting a new token.
+     * It will emit the current token when you subscribe and then emit new tokens when they are set.
      */
-    get tokenUpdates$() {
-        return this.tokenSubject$.asObservable();
+    get token$() {
+        return this.tokenSubject$.asObservable().pipe(filter(Boolean));
     }
     getStatus() {
         return true;
@@ -54,7 +55,12 @@ export class AuthService extends BaseServiceAbstract {
         }
         this.config.token = this.token.value;
         // output a message for token change
-        this.tokenSubject$?.next(this.token);
+        if (this.isTokenValid(this.token)) {
+            this.tokenSubject$.next(this.token);
+        }
+        else {
+            void this.getToken();
+        }
     }
     /**
      * Clear token

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dronedeploy/rocos-js-sdk",
-  "version": "3.0.1-alpha.20",
+  "version": "3.0.1-alpha.22",
   "description": "Javascript SDK for rocos",
   "main": "cjs/index.js",
   "module": "esm/index.js",
@@ -27,6 +27,7 @@
     "@protobuf-ts/plugin": "^2.9.1",
     "@protobuf-ts/runtime": "^2.9.1",
     "@types/json-schema": "^7.0.14",
+    "acorn": "^8.11.3",
     "buffer": "^6.0.3",
     "loglevel": "^1.7.1",
     "loglevel-plugin-prefix": "^0.8.4",