vsn 0.1.58 → 0.1.59

package/package.json

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

package/src/AST/FunctionNode.ts

@@ -1,17 +1,17 @@
 import {Scope} from "../Scope";
 import {DOM} from "../DOM";
 import {Tag} from "../Tag";
-import {Token, TreeNode} from "../AST";
+import {Token, Tree, TreeNode} from "../AST";
 import {Node} from "./Node";
-import {LiteralNode} from "./LiteralNode";
-import {RootScopeMemberNode} from "./RootScopeMemberNode";
-import {ScopeMemberNode} from "./ScopeMemberNode";
+import {BlockNode} from "./BlockNode";
 
 export class FunctionNode extends Node implements TreeNode {
+    protected requiresPrep: boolean = true;
+
     constructor(
-        public readonly name: LiteralNode<string>,
-        public readonly variables: LiteralNode<string>[],
-        public readonly block: RootScopeMemberNode | ScopeMemberNode,
+        public readonly name: string,
+        public readonly args: string[],
+        public readonly block: BlockNode
     ) {
         super();
     }
@@ -22,10 +22,29 @@ export class FunctionNode extends Node implements TreeNode {
         ];
     }
 
-    public async prepare(scope: Scope, dom: DOM, tag: Tag = null) {}
-    public async evaluate(scope: Scope, dom: DOM, tag: Tag = null) {}
+    public async prepare(scope: Scope, dom: DOM, tag: Tag = null) {
+        scope.set(this.name, 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);
+    }
 
     public static parse(lastNode, token, tokens: Token[]): FunctionNode {
-        return new FunctionNode(null, null, null);
+        tokens.shift(); // skip 'func'
+        const name = tokens.shift();
+        const argTokens = Tree.getBlockTokens(tokens);
+        const funcArgs: string[] = [];
+        for (const t of argTokens) {
+            funcArgs.push(t[0].value);
+        }
+        const block = Tree.processTokens(Tree.getBlockTokens(tokens, null)[0]);
+        return new FunctionNode(name.value, funcArgs, block);
     }
 }

package/src/AST.ts

@@ -26,6 +26,7 @@ import {BooleanLiteralNode} from "./AST/BooleanLiteralNode";
 import {NotNode} from "./AST/NotNode";
 import {XHRNode} from "./AST/XHRNode";
 import {StringFormatNode} from "./AST/StringFormatNode";
+import {FunctionNode} from "./AST/FunctionNode";
 
 function lower(str: string): string {
     return str ? str.toLowerCase() : null;
@@ -65,6 +66,7 @@ export enum TokenType {
     IF,
     ELSE_IF,
     ELSE,
+    FUNC,
     NAME,
     L_BRACE,
     R_BRACE,
@@ -194,6 +196,10 @@ const TOKEN_PATTERNS: TokenPattern[] = [
         type: TokenType.ELSE,
         pattern: /^else\s?(?=\{)/
     },
+    {
+        type: TokenType.FUNC,
+        pattern: /^func\s/
+    },
     {
         type: TokenType.ELEMENT_ATTRIBUTE,
         pattern: /^\.?@[-_a-zA-Z0-9]*/
@@ -482,6 +488,10 @@ export class Tree {
                 node = ForStatementNode.parse(node, token, tokens);
                 blockNodes.push(node);
                 node = null;
+            } else if (token.type === TokenType.FUNC) {
+                node = FunctionNode.parse(node, token, tokens);
+                blockNodes.push(node);
+                node = null;
             } else if (StringFormatNode.match(tokens)) {
                 node = StringFormatNode.parse(node, tokens[0], tokens);
             } else if (token.type === TokenType.STRING_LITERAL) {

package/src/attributes/Exec.ts

@@ -7,8 +7,12 @@ export class Exec extends Attribute {
     public static readonly canDefer: boolean = false;
     protected tree: Tree;
 
+    public get code() {
+        return this.getAttributeValue();
+    }
+
     public async compile() {
-        this.tree = new Tree(this.getAttributeValue());
+        this.tree = new Tree(this.code);
         await this.tree.prepare(this.tag.scope, this.tag.dom, this.tag);
         await super.compile();
     }

package/src/attributes/ScriptAttribute.ts

@@ -0,0 +1,9 @@
+import {Registry} from "../Registry";
+import {Exec} from "./Exec";
+
+@Registry.attribute('vsn-script')
+export class ScriptAttribute extends Exec {
+    public get code() {
+        return this.tag.element.innerText;
+    }
+}

package/src/attributes/StandardAttribute.ts

@@ -16,7 +16,6 @@ export class StandardAttribute extends Attribute {
     }
 
     public async connect() {
-        this.tag.scope.on(`change:${this.key}`, (v) => { console.log('updated', v);});
         this.tag.scope.on(`change:${this.key}`, this.updateTo.bind(this));
         await super.connect();
     }

package/src/attributes/_imports.ts

@@ -19,6 +19,7 @@ export {Referenced} from "./Referenced";
 export {RootAttribute} from "./RootAttribute";
 export {ScopeAttribute} from "./ScopeAttribute";
 export {ScopeChange} from "./ScopeChange";
+export {ScriptAttribute} from "./ScriptAttribute";
 export {SetAttribute} from "./SetAttribute";
 export {StandardAttribute} from "./StandardAttribute";
 export {StyleAttribute} from "./StyleAttribute";

package/test/AST/FunctionNode.spec.ts

@@ -0,0 +1,14 @@
+import {Tree} from "../../src/AST";
+import {Scope} from "../../src/Scope";
+
+
+describe('FunctionNode', () => {
+    it("properly define a simple function", async () => {
+        const tree = new Tree(`func add(a, b) { return a + b; }; add(1, 2);`);
+        const scope = new Scope();
+        await tree.prepare(scope, null, null);
+        expect(scope.get('add')).toBeDefined();
+        const v = await tree.evaluate(scope, null, null);
+        expect(v).toBe(3);
+    });
+});