vsn 0.1.59 → 0.1.60

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vsn",
-  "version": "0.1.59",
+  "version": "0.1.60",
   "description": "SEO Friendly Javascript/Typescript Framework",
   "keywords": [
     "framework",

package/src/AST/ArithmeticAssignmentNode.ts

@@ -59,7 +59,7 @@ export class ArithmeticAssignmentNode extends Node implements TreeNode {
         const values = [];
         for (let localScope of scopes) {
             if (localScope instanceof DOMObject) {
-                await this.handleDOMObject(name, dom, localScope, tag);
+                await this.handleDOMObject(name, dom, scope, localScope, tag);
             } else {
                 if (localScope['$wrapped'] && localScope['$scope']) {
                     localScope = localScope['$scope'];
@@ -68,16 +68,7 @@ export class ArithmeticAssignmentNode extends Node implements TreeNode {
                 // We get the values from the passed scope, but set the value on the local scope
                 let left: number | Array<any> | string = await this.left.evaluate(scope, dom, tag);
                 let right: number | Array<any> | string = await this.right.evaluate(scope, dom, tag);
-
-                if (left instanceof Array) {
-                    left = this.handleArray(name, left, right, localScope);
-                } else if ((left as any) instanceof UnitLiteral || right instanceof UnitLiteral) {
-                    left = this.handleUnit(name, left, right, localScope);
-                } else if (Number.isFinite(left)) {
-                    left = this.handleNumber(name, left, right, localScope);
-                } else {
-                    left = this.handleString(name, left, right, localScope);
-                }
+                left = this.handle(name, left, right, localScope);
 
                 values.push(left);
             }
@@ -85,6 +76,20 @@ export class ArithmeticAssignmentNode extends Node implements TreeNode {
         return values.length > 1 ? values : values[0];
     }
 
+    public handle(name, left, right, localScope) {
+        if (left instanceof Array) {
+            left = this.handleArray(name, left, right, localScope);
+        } else if ((left as any) instanceof UnitLiteral || right instanceof UnitLiteral) {
+            left = this.handleUnit(name, left, right, localScope);
+        } else if (Number.isFinite(left)) {
+            left = this.handleNumber(name, left, right, localScope);
+        } else {
+            left = this.handleString(name, left, right, localScope);
+        }
+
+        return left;
+    }
+
     public handleNumber(key, left, right, scope) {
         if (right !== null && !Number.isFinite(right))
             right = parseFloat(`${right}`);
@@ -167,13 +172,10 @@ export class ArithmeticAssignmentNode extends Node implements TreeNode {
         return left;
     }
 
-    public async handleDOMObject(key: string, dom: DOM, domObject: DOMObject, tag: Tag) {
+    public async handleDOMObject(key: string, dom: DOM, scope: Scope, domObject: DOMObject, tag: Tag) {
         let left = domObject.scope.get(key);
-        let right: number | Array<any> | string = await this.right.evaluate(domObject.scope, dom, tag);
-        if (left instanceof Array)
-            return this.handleArray(key, left, right, domObject.scope);
-
-        return this.handleString(key, left, right, domObject.scope);
+        let right: number | Array<any> | string = await this.right.evaluate(scope, dom, tag);
+        return this.handle(key, left, right, domObject.scope);
     }
 
     public handleArray(key, left, right, scope) {

package/src/AST/FunctionCallNode.ts

@@ -5,6 +5,7 @@ import {TreeNode} from "../AST";
 import {Node} from "./Node";
 import {FunctionArgumentNode} from "./FunctionArgumentNode";
 import {ScopeMemberNode} from "./ScopeMemberNode";
+import {FunctionNode} from "./FunctionNode";
 
 export class FunctionCallNode<T = any> extends Node implements TreeNode {
     constructor(
@@ -27,6 +28,11 @@ export class FunctionCallNode<T = any> extends Node implements TreeNode {
             functionScope = await this.fnc.scope.evaluate(scope, dom, tag);
         }
         const values = await this.args.evaluate(scope, dom, tag);
-        return (await this.fnc.evaluate(scope, dom, tag)).call(functionScope.wrapped || functionScope, ...values);
+        const func = await this.fnc.evaluate(scope, dom, tag);
+        if (func instanceof FunctionNode) {
+            return (await func.evaluate(functionScope, dom, tag) as any)(...values);
+        } else {
+            return func.call(functionScope.wrapped || functionScope, ...values);
+        }
     }
 }

package/src/AST/FunctionNode.ts

@@ -22,18 +22,19 @@ export class FunctionNode extends Node implements TreeNode {
         ];
     }
 
-    public async prepare(scope: Scope, dom: DOM, tag: Tag = null) {
-        scope.set(this.name, async (...args) => {
+    public async prepare(scope: Scope, dom: DOM, tag: Tag = null): Promise<void> {
+        scope.set(this.name, this);
+        await super.prepare(scope, dom, tag);
+    }
+
+    public async evaluate(scope: Scope, dom: DOM, tag: Tag = null) {
+        return async (...args) => {
             const functionScope = new Scope(scope);
             for (const arg of this.args) {
                 functionScope.set(arg, args.shift());
             }
-            return await this.evaluate(functionScope, dom, tag);
-        });
-    }
-
-    public async evaluate(scope: Scope, dom: DOM, tag: Tag = null) {
-        return await this.block.evaluate(scope, dom, tag);
+            return await this.block.evaluate(functionScope, dom, tag);
+        }
     }
 
     public static parse(lastNode, token, tokens: Token[]): FunctionNode {

package/src/Scope.ts

@@ -220,4 +220,10 @@ export class Scope extends EventDispatcher {
             delete toUnwrap[field];
         }
     }
+
+    public static fromObject(obj, parentScope?: Scope): Scope {
+        const scope = new Scope(parentScope);
+        scope.wrap(obj);
+        return scope;
+    }
 }

package/src/attributes/RootAttribute.ts

@@ -1,6 +1,7 @@
 import {Attribute} from "../Attribute";
 import {VisionHelper} from "../helpers/VisionHelper";
 import {Registry} from "../Registry";
+import {Scope} from "../Scope";
 
 @Registry.attribute('vsn-root')
 export class RootAttribute extends Attribute {
@@ -9,6 +10,8 @@ export class RootAttribute extends Attribute {
 
     public async setup() {
         this.tag.scope.set('$mobile', VisionHelper.isMobile());
+        if (console && !this.tag.scope.get('console'))
+            this.tag.scope.set('console', Scope.fromObject(console));
         await super.setup();
     }
 }

package/src/vsn.ts

@@ -55,7 +55,7 @@ export class Vision extends EventDispatcher {
         await this._dom.buildFrom(document, true);
         const now = (new Date()).getTime();
         const setupTime = now - startTime;
-        console.warn(`Took ${setupTime}ms to start up VisionJS. https://www.vsnjs.com/`, window ? `v${window['VSN_VERSION']}` : null);
+        console.info(`Took ${setupTime}ms to start up VisionJS. https://www.vsnjs.com/`, window ? `v${window['VSN_VERSION']}` : null);
     }
 
     public static get instance() {