vsn 0.1.106 → 0.1.107

package/package.json

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

package/src/AST/AsNode.ts

@@ -0,0 +1,32 @@
+import {Scope} from "../Scope";
+import {DOM} from "../DOM";
+import {Tag} from "../Tag";
+import {Token, TreeNode} from "../AST";
+import {Node} from "./Node";
+
+export class AsNode extends Node implements TreeNode {
+    constructor(
+        public readonly context: Node,
+        public readonly name: string
+    ) {
+        super();
+    }
+
+    protected _getChildNodes(): Node[] {
+        return [
+            this.context
+        ]
+    }
+
+    public async evaluate(scope: Scope, dom: DOM, tag: Tag = null) {
+        const context = await this.context.evaluate(scope, dom, tag);
+        scope.set(this.name, context);
+        return context;
+    }
+
+    public static parse(lastNode, token, tokens: Token[]) {
+        tokens.shift(); // Consume as
+        const name = tokens.shift();
+        return new AsNode(lastNode, name.value);
+    }
+}

package/src/AST/DispatchEventNode.ts

@@ -0,0 +1,50 @@
+import {Scope} from "../Scope";
+import {DOM} from "../DOM";
+import {Tag} from "../Tag";
+import {Token, TokenType, Tree, TreeNode} from "../AST";
+import {Node} from "./Node";
+import {ObjectNode} from "./ObjectNode";
+import {ScopeData} from "../Scope/ScopeData";
+
+export class DispatchEventNode extends Node implements TreeNode {
+    constructor(
+        public readonly name: string,
+        public readonly data: ObjectNode | null,
+        public readonly bubbles: boolean = false
+    ) {
+        super();
+    }
+
+    protected _getChildNodes(): Node[] {
+        const nodes: Node[] = [];
+        if (this.data)
+            nodes.push(this.data);
+        return nodes;
+    }
+
+    public async evaluate(scope: Scope, dom: DOM, tag: Tag = null) {
+        let detail = this.data ? await this.data.evaluate(scope, dom, tag) : {};
+        if (detail instanceof Scope)
+            detail = detail.data.getData();
+        else if (detail instanceof ScopeData)
+            detail = detail.getData();
+
+        detail['source'] = tag.element;
+
+        tag.element.dispatchEvent(new CustomEvent(this.name, {
+            bubbles: this.bubbles,
+            detail: detail
+        }));
+    }
+
+    public static parse(lastNode, token, tokens: Token[]) {
+        const name = tokens.shift();
+        let data: ObjectNode = null;
+        if (tokens.length && tokens[0].type === TokenType.L_PAREN) {
+            const containedTokens = Tree.getNextStatementTokens(tokens, true, true, false);
+            data = Tree.processTokens(containedTokens).statements[0] as ObjectNode;
+        }
+
+        return new DispatchEventNode(name.value, data, name.full.startsWith('!!!'));
+    }
+}

package/src/AST/WithNode.ts

@@ -0,0 +1,45 @@
+import {Scope} from "../Scope";
+import {DOM} from "../DOM";
+import {Tag} from "../Tag";
+import {BlockType, 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 {
+    constructor(
+        public readonly context: Node,
+        public readonly statements: BlockNode
+    ) {
+        super();
+    }
+
+    protected _getChildNodes(): Node[] {
+        return [
+            this.context,
+            this.statements
+        ]
+    }
+
+    public async evaluate(scope: Scope, dom: DOM, tag: Tag = null) {
+        const context = await this.context.evaluate(scope, dom, tag);
+        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))
+        }
+        return ret.length === 1 ? ret[0] : ret;
+    }
+
+    public static parse(lastNode, token, tokens: Token[]) {
+        tokens.shift(); // Consume with
+        const contextTokens = Tree.getTokensUntil(tokens, TokenType.L_BRACE, false, false, true);
+        const statementTokens = Tree.getNextStatementTokens(tokens);
+        return new WithNode(Tree.processTokens(contextTokens), Tree.processTokens(statementTokens));
+    }
+}

package/src/AST.ts

@@ -30,6 +30,9 @@ import {FunctionNode} from "./AST/FunctionNode";
 import {ClassNode} from "./AST/ClassNode";
 import {OnNode} from "./AST/OnNode";
 import {ModifierNode} from "./AST/ModifierNode";
+import {DispatchEventNode} from "./AST/DispatchEventNode";
+import {WithNode} from "./AST/WithNode";
+import {AsNode} from "./AST/AsNode";
 
 function lower(str: string): string {
     return str ? str.toLowerCase() : null;
@@ -64,7 +67,9 @@ export enum TokenType {
     RETURN,
     NOT,
     OF,
+    AS,
     IN,
+    WITH,
     FOR,
     IF,
     ELSE_IF,
@@ -119,6 +124,7 @@ export enum TokenType {
     XHR_PUT,
     XHR_DELETE,
     MODIFIER,
+    DISPATCH_EVENT,
 }
 
 const TOKEN_PATTERNS: TokenPattern[] = [
@@ -142,6 +148,10 @@ const TOKEN_PATTERNS: TokenPattern[] = [
         type: TokenType.XHR_DELETE,
         pattern: /^></
     },
+    {
+        type: TokenType.DISPATCH_EVENT,
+        pattern: /^!!!?([_a-zA-Z][-_a-zA-Z0-9]+)/
+    },
     {
         type: TokenType.TYPE_INT,
         pattern: /^int+/
@@ -186,6 +196,14 @@ const TOKEN_PATTERNS: TokenPattern[] = [
         type: TokenType.IN,
         pattern: /^in\s/
     },
+    {
+        type: TokenType.AS,
+        pattern: /^as\s/
+    },
+    {
+        type: TokenType.WITH,
+        pattern: /^with\s/
+    },
     {
         type: TokenType.FOR,
         pattern: /^for\s?(?=\()/
@@ -499,6 +517,12 @@ export class Tree {
                 tokens.shift()
             } else if (XHRNode.match(tokens)) {
                 node = XHRNode.parse(node, tokens[0], tokens);
+            } else if (token.type === TokenType.DISPATCH_EVENT) {
+                node = DispatchEventNode.parse(node, tokens[0], tokens);
+            } else if (token.type === TokenType.WITH) {
+                node = WithNode.parse(node, tokens[0], tokens);
+            } 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);
                 blockNodes.push(node);
@@ -730,13 +754,13 @@ export class Tree {
         for (let i: number = 0; i < tokens.length; i++) {
             const token: Token = tokens[i];
             if (!(token.type === blockInfo.open && i === 0)) { // Skip opener
-                if (token.type === TokenType.L_PAREN)
+                if (token.type === TokenType.L_PAREN && terminator !== TokenType.L_PAREN)
                     openParens += 1;
 
-                if (token.type === TokenType.L_BRACE)
+                if (token.type === TokenType.L_BRACE && terminator !== TokenType.L_BRACE)
                     openBraces += 1;
 
-                if (token.type === TokenType.L_BRACKET)
+                if (token.type === TokenType.L_BRACKET && terminator !== TokenType.L_BRACKET)
                     openBrackets += 1;
             }
 

package/src/Component.ts

@@ -47,5 +47,6 @@ export class Component extends HTMLElement {
         for (const componentTag of componentTags) {
             await DOM.instance.resetBranch(componentTag);
         }
+        await DOM.instance.setupTags([tag]);
     }
 }

package/src/DOM.ts

@@ -132,16 +132,16 @@ export class DOM extends EventDispatcher {
                 const nodeList = [];
                 for (const _element of Array.from(this.querySelectorElement(element, _q))) {
                     if (rest.length > 0) {
-                        nodeList.push(...Array.from(this.querySelectorElement(_element.parentElement, rest)));
+                        nodeList.push(...Array.from(this.querySelectorElement(DOM.getParentElement(_element as HTMLElement), rest)));
                     } else {
-                        nodeList.push(_element.parentElement);
+                        nodeList.push(DOM.getParentElement(_element as HTMLElement));
                     }
                 }
                 return nodeList;
             } else if (rest.length === 0) {
-                return [element.parentElement];
+                return [DOM.getParentElement(element as HTMLElement)];
             } else {
-                return this.querySelectorElement(element.parentElement, rest);
+                return this.querySelectorElement(DOM.getParentElement(element as HTMLElement), rest);
             }
         }
         let matches = element.querySelectorAll(q);

package/src/version.ts

@@ -1,2 +1,2 @@
-export const VERSION = '0.1.106';
+export const VERSION = '0.1.107';