vsn 0.1.119 → 0.1.121

package/dist/version.js

@@ -1,5 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VERSION = void 0;
-exports.VERSION = '0.1.118';
+exports.VERSION = '0.1.121';
 //# sourceMappingURL=version.js.map

package/package.json

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

package/src/AST/ModifierNode.ts

@@ -24,7 +24,9 @@ export class ModifierNode extends Node implements TreeNode {
 
     public static parse(lastNode, token, tokens: Token[]): Node {
         const modifier = tokens.shift().value.substr(1);
-        lastNode.modifiers.push(modifier);
+        if (lastNode) {
+            lastNode.modifiers.push(modifier);
+        }
         return lastNode;
     }
 }

package/src/AST/Node.ts

@@ -1,7 +1,7 @@
 import {Scope} from "../Scope";
 import {DOM} from "../DOM";
 import {Tag} from "../Tag";
-import {TreeNode} from "../AST";
+import {Token, TokenType, TreeNode} from "../AST";
 
 export interface INodeMeta {
     [key: string]: string | number | boolean | null;
@@ -78,5 +78,15 @@ export abstract class Node implements TreeNode {
 
         return nodes;
     }
+
+    hasModifier(modifier: string): boolean {
+        return this.modifiers.indexOf(modifier) !== -1;
+    }
+
+    public static moveModifiers(from: Token[], to: Token[]) {
+        while (from[0].type == TokenType.MODIFIER) {
+            to.unshift(from.shift());
+        }
+    }
 }
 

package/src/AST/WithNode.ts

@@ -1,12 +1,14 @@
 import {Scope} from "../Scope";
 import {DOM} from "../DOM";
 import {Tag} from "../Tag";
-import {BlockType, Token, TokenType, Tree, TreeNode} from "../AST";
+import {Token, TokenType, Tree, TreeNode} from "../AST";
 import {Node} from "./Node";
 import {BlockNode} from "./BlockNode";
 import {TagList} from "../Tag/TagList";
 
 export class WithNode extends Node implements TreeNode {
+    protected requiresPrep: boolean = true;
+
     constructor(
         public readonly context: Node,
         public readonly statements: BlockNode
@@ -23,15 +25,35 @@ export class WithNode extends Node implements TreeNode {
 
     public async evaluate(scope: Scope, dom: DOM, tag: Tag = null) {
         const context = await this.context.evaluate(scope, dom, tag);
-        let tags;
+        let tags = [];
         if (context instanceof TagList) {
             tags = context;
         } else if (context instanceof Tag) {
             tags = [context];
         }
         let ret = [];
-        for (const _tag of tags) {
-            ret.push(await this.statements.evaluate(_tag.scope, dom, _tag))
+        if (tags.length) {
+            if (this.hasModifier('sequential')) { // More like a for loop, needed?
+                for (const _tag of tags) {
+                    await this.statements.prepare(_tag.scope, dom, _tag);
+                    ret.push(await this.statements.evaluate(_tag.scope, dom, _tag));
+                }
+            } else {
+                const promises = [];
+                for (const _tag of tags) {
+                    await this.statements.prepare(_tag.scope, dom, _tag);
+                    promises.push(this.statements.evaluate(_tag.scope, dom, _tag));
+                }
+                ret = await Promise.all(promises);
+            }
+        } else {
+            let _scope;
+            if (context instanceof Scope) {
+                _scope = context;
+            }
+
+            if (_scope)
+                ret.push(await this.statements.evaluate(_scope, dom, tag))
         }
         return ret.length === 1 ? ret[0] : ret;
     }
@@ -40,6 +62,7 @@ export class WithNode extends Node implements TreeNode {
         tokens.shift(); // Consume with
         const contextTokens = Tree.getTokensUntil(tokens, TokenType.L_BRACE, false, false, true);
         const statementTokens = Tree.getNextStatementTokens(tokens);
+        this.moveModifiers(contextTokens, tokens);
         return new WithNode(Tree.processTokens(contextTokens), Tree.processTokens(statementTokens));
     }
 }

package/src/AST.ts

@@ -202,7 +202,7 @@ const TOKEN_PATTERNS: TokenPattern[] = [
     },
     {
         type: TokenType.WITH,
-        pattern: /^with\s/
+        pattern: /^with(?=\||\s)?/  // Allows with|sequential
     },
     {
         type: TokenType.FOR,
@@ -495,9 +495,10 @@ export class Tree {
         return tokens;
     }
 
-    public static processTokens(tokens: Token[]): BlockNode {
+    public static processTokens(tokens: Token[], _node: Node=null, _lastBlock: Node=null): BlockNode {
         let blockNodes: Node[] = [];
-        let node: Node = null;
+        let lastBlock: Node = _lastBlock;
+        let node: Node = _node;
         let count: number = 0;
 
         Tree.stripWhiteSpace(tokens);
@@ -521,26 +522,34 @@ export class Tree {
                 node = DispatchEventNode.parse(node, tokens[0], tokens);
             } else if (token.type === TokenType.WITH) {
                 node = WithNode.parse(node, tokens[0], tokens);
+                lastBlock = node;
+                blockNodes.push(node);
+                node = null;
             } else if (token.type === TokenType.AS) {
                 node = AsNode.parse(node, tokens[0], tokens);
             } else if (token.type === TokenType.IF) {
                 node = IfStatementNode.parse(node, token, tokens);
+                lastBlock = node;
                 blockNodes.push(node);
                 node = null;
             } else if (token.type === TokenType.FOR) {
                 node = ForStatementNode.parse(node, token, tokens);
+                lastBlock = node;
                 blockNodes.push(node);
                 node = null;
             } else if (token.type === TokenType.FUNC) {
                 node = FunctionNode.parse(node, token, tokens);
+                lastBlock = node;
                 blockNodes.push(node);
                 node = null;
             } else if (token.type === TokenType.ON) {
                 node = OnNode.parse(node, token, tokens);
+                lastBlock = node;
                 blockNodes.push(node);
                 node = null;
             } else if (token.type === TokenType.CLASS) {
                 node = ClassNode.parse(node, token, tokens);
+                lastBlock = node;
                 blockNodes.push(node);
                 node = null;
             } else if (StringFormatNode.match(tokens)) {
@@ -618,7 +627,7 @@ export class Tree {
             } else if (tokens[0].type === TokenType.EXCLAMATION_POINT) {
                 node = NotNode.parse(node, tokens[0], tokens);
             } else if (tokens[0].type === TokenType.MODIFIER) {
-                node = ModifierNode.parse(node, tokens[0], tokens);
+                ModifierNode.parse(node ? node : lastBlock, tokens[0], tokens);
             } else {
                 let code: string = Tree.toCode(tokens, 10);
                 throw Error(`Syntax Error. Near ${code}`);

package/src/Scope.ts

@@ -4,6 +4,7 @@ import {QueryReference} from "./Scope/QueryReference";
 import {WrappedArray} from "./Scope/WrappedArray";
 import {ScopeData} from "./Scope/ScopeData";
 import {DynamicScopeData} from "./Scope/DynamicScopeData";
+import {DOM} from "./DOM";
 
 
 export class Scope extends EventDispatcher {
@@ -28,7 +29,11 @@ export class Scope extends EventDispatcher {
     }
 
     public get parentScope(): Scope {
-        return this._parentScope;
+        if (this._parentScope)
+            return this._parentScope;
+
+        const rootScope = DOM.instance.root.scope;
+        return this == rootScope ? null : rootScope;
     }
 
     public set parentScope(scope: Scope) {

package/src/version.ts

@@ -1,2 +1,2 @@
-export const VERSION = '0.1.119';
+export const VERSION = '0.1.121';