vsn 0.1.43 → 0.1.46

package/src/AST/WASM.ts

@@ -0,0 +1,244 @@
+import {VisionHelper} from "../helpers/VisionHelper";
+import {FunctionSection} from "./WASM/Function";
+
+
+const dummyFunc = (...args: any[]): any => null;
+const dummyVal = null;
+
+let _ieee754 = dummyFunc;
+let _encodeString = dummyFunc;
+let _signedLEB128 = dummyFunc;
+let _unsignedLEB128 = dummyFunc;
+
+
+_ieee754 = (n: number) => {
+    const buf = Buffer.allocUnsafe(4);
+    buf.writeFloatLE(n, 0);
+    return Uint8Array.from(buf);
+};
+
+_encodeString = (str: string) => [
+    str.length,
+    ...str.split("").map(s => s.charCodeAt(0))
+];
+
+_signedLEB128 = (n: number) => {
+    const buffer = [];
+    let more = true;
+    const isNegative = n < 0;
+    const bitCount = Math.ceil(Math.log2(Math.abs(n))) + 1;
+    while (more) {
+        let byte = n & 0x7f;
+        n >>= 7;
+        if (isNegative) {
+            n = n | -(1 << (bitCount - 8));
+        }
+        if ((n === 0 && (byte & 0x40) === 0) || (n === -1 && (byte & 0x40) !== 0x40)) {
+            more = false;
+        } else {
+            byte |= 0x80;
+        }
+        buffer.push(byte);
+    }
+    return buffer;
+};
+
+_unsignedLEB128 = (n: number) => {
+    const buffer = [];
+    do {
+        let byte = n & 0x7f;
+        n >>>= 7;
+        if (n !== 0) {
+            byte |= 0x80;
+        }
+        buffer.push(byte);
+    } while (n !== 0);
+    return buffer;
+};
+
+
+export const ieee754 = _ieee754;
+export const encodeString = _encodeString;
+export const signedLEB128 = _signedLEB128;
+export const unsignedLEB128 = _unsignedLEB128;
+
+export const flatten = (arr: any[]) => {
+    return [].concat.apply([], arr);
+}
+
+enum ESectionType {
+    custom = 0,
+    type = 1,
+    import = 2,
+    func = 3,
+    table = 4,
+    memory = 5,
+    global = 6,
+    export = 7,
+    start = 8,
+    element = 9,
+    code = 10,
+    data = 11
+}
+
+// https://webassembly.github.io/spec/core/binary/types.html
+export enum EValueType {
+    i32 = 0x7f,
+    f32 = 0x7d
+}
+
+// https://webassembly.github.io/spec/core/binary/types.html#binary-blocktype
+export enum EBlockType {
+    void = 0x40
+}
+
+// https://webassembly.github.io/spec/core/binary/instructions.html
+export enum EOpCode {
+    block = 0x02,
+    loop = 0x03,
+    br = 0x0c,
+    br_if = 0x0d,
+    end = 0x0b,
+    call = 0x10,
+    get_local = 0x20,
+    set_local = 0x21,
+    i32_store_8 = 0x3a,
+    i32_const = 0x41,
+    f32_const = 0x43,
+    i32_add = 0x6a,
+    i32_sub = 0x6B,
+    i32_mul = 0x6C,
+    i32_div = 0x6D,
+    i32_eqz = 0x45,
+    i32_eq = 0x46,
+    f32_eq = 0x5b,
+    f32_lt = 0x5d,
+    f32_gt = 0x5e,
+    i32_and = 0x71,
+    f32_add = 0x92,
+    f32_sub = 0x93,
+    f32_mul = 0x94,
+    f32_div = 0x95,
+    i32_trunc_f32_s = 0xa8,
+    memory_size = 0x3f,
+    memory_grow = 0x40,
+
+    // Vision op codes
+    scope_get = 0x400,
+    scope_set = 0x401
+}
+
+const binaryOpcode = {
+    "+": EOpCode.f32_add,
+    "-": EOpCode.f32_sub,
+    "*": EOpCode.f32_mul,
+    "/": EOpCode.f32_div,
+    "==": EOpCode.f32_eq,
+    ">": EOpCode.f32_gt,
+    "<": EOpCode.f32_lt,
+    "&&": EOpCode.i32_and
+};
+
+// http://webassembly.github.io/spec/core/binary/modules.html#export-section
+export enum EExportType {
+    func = 0x00,
+    table = 0x01,
+    mem = 0x02,
+    global = 0x03
+}
+
+// http://webassembly.github.io/spec/core/binary/types.html#function-types
+export const functionType = 0x60;
+
+export const emptyArray = 0x0;
+
+// https://webassembly.github.io/spec/core/binary/modules.html#binary-module
+const magicModuleHeader = [0x00, 0x61, 0x73, 0x6d];
+const moduleVersion = [0x01, 0x00, 0x00, 0x00];
+
+// https://webassembly.github.io/spec/core/binary/conventions.html#binary-vec
+// Vectors are encoded with their length followed by their element sequence
+export const encodeVector = (data: any[]) => [
+    ...unsignedLEB128(data.length),
+    ...flatten(data)
+];
+
+// https://webassembly.github.io/spec/core/binary/modules.html#code-section
+export const encodeLocal = (count: number, type: EValueType) => [
+    ...unsignedLEB128(count),
+    type
+];
+
+// https://webassembly.github.io/spec/core/binary/modules.html#sections
+// sections are encoded by their type followed by their vector contents
+const createSection = (sectionType: ESectionType, data: any[]) => [
+    sectionType,
+    ...encodeVector(data)
+];
+
+/*
+    Building a WASM program...
+    Based off of Chasm:
+    https://github.com/ColinEberhardt/chasm/blob/master/src/emitter.ts
+    https://webassembly.github.io/wabt/demo/wat2wasm/
+*/
+
+export const emitter = (functions: FunctionSection[]) => {
+    // Types section
+    const typesSection = createSection(ESectionType.type, [
+        functions.length, // Number of types
+        ...flatten(functions.map((func) => func.sectionTypes))
+    ]);
+
+    // Functions section
+    const functionsSection = createSection(ESectionType.func, [
+        functions.length, // number of functions
+        ...functions.map((func, i) => i)
+    ]);
+
+    // Export section
+    const exportSection = createSection(
+        ESectionType.export,
+        encodeVector(functions.map((func,i) => [...func.sectionExport, i]))
+    );
+
+    const codeSection = createSection(ESectionType.code, [
+        functions.length, // Number of functions
+        ...flatten(functions.map((func) => func.sectionCode))
+    ]);
+
+    return Uint8Array.from([
+        ...magicModuleHeader,
+        ...moduleVersion,
+        ...typesSection,
+        ...functionsSection,
+        ...exportSection,
+        ...codeSection
+    ]);
+}
+
+const defaultMemory: WebAssembly.Memory = new WebAssembly.Memory({initial: 10, maximum: 100, shared: true} as WebAssembly.MemoryDescriptor);
+
+export async function compile(functions: FunctionSection[], memory?: WebAssembly.Memory) {
+    memory = memory || defaultMemory;
+    const wasm = emitter(functions);
+    return await WebAssembly.instantiate(wasm, {
+        js: {
+            memory: memory
+        }
+    });
+}
+
+export async function run(functions: FunctionSection | FunctionSection[], ...args) {
+    const memory = args[0] instanceof WebAssembly.Memory && args[0] || defaultMemory;
+    if (functions instanceof FunctionSection)
+        functions = [functions];
+
+    const wasm = await compile(functions, memory);
+    return 'main' in wasm.instance.exports ? (wasm.instance.exports.main as any)(...args) : wasm;
+}
+
+if (VisionHelper.window)
+    window['wasm'] = {
+        compile: compile
+    }

package/src/AST/XHRNode.ts

@@ -0,0 +1,81 @@
+import {Node} from "./Node";
+import {Token, TokenType, Tree, TreeNode} from "../AST";
+import {Scope} from "../Scope";
+import {DOM} from "../DOM";
+import {Tag} from "../Tag";
+import {ScopeDataAbstract} from "../Scope/ScopeDataAbstract";
+
+export class XHRNode extends Node implements TreeNode {
+    constructor(
+        public readonly left: Node | null,
+        public readonly requestType: TokenType,
+        public readonly url: Node
+    ) {
+        super();
+    }
+
+    public getChildNodes(): Node[] {
+        const nodes = [this.url];
+        if (this.left)
+            nodes.push(this.left);
+        return nodes;
+    }
+
+    async evaluate(scope: Scope, dom: DOM, tag?: Tag) {
+        const url = await this.url.evaluate(scope, dom, tag);
+        let method: string;
+        let data = this.left ? await this.left.evaluate(scope, dom, tag) : {};
+
+        if (data instanceof Scope)
+            data = data.data;
+
+        if (data instanceof ScopeDataAbstract)
+            data = data.getData();
+
+        switch (this.requestType) {
+            case TokenType.XHR_POST:
+                method = "POST";
+                break;
+            case TokenType.XHR_PUT:
+                method = "PUT";
+                break;
+            case TokenType.XHR_DELETE:
+                method = "DELETE";
+                break;
+            default:
+                method = "GET";
+        }
+
+        let request = {
+            method: method
+        };
+
+        if (request.method === 'GET') {
+
+        } else {
+            request['body'] = (typeof data === "string") ? data : JSON.stringify(data);
+        }
+
+        const response = await fetch(url, request);
+        const contentType = response.headers.get('content-type');
+        if (contentType && contentType.includes('application/json')) {
+            return await response.json();
+        }
+        return await response.text();
+    }
+
+    public static parse(node: Node, token: Token, tokens: Token[]): XHRNode {
+        tokens.splice(0, 1); // Consume request type
+        const url = Tree.processTokens(Tree.getNextStatementTokens(tokens, false, false, false));
+        return new XHRNode(node, token.type, url);
+    }
+
+    public static match(tokens: Token[]) {
+        return [
+            TokenType.XHR_POST,
+            TokenType.XHR_PUT,
+            TokenType.XHR_GET,
+            TokenType.XHR_DELETE,
+        ].indexOf(tokens[0].type) > -1;
+    }
+}

package/src/AST.ts

@@ -24,6 +24,8 @@ import {ArithmeticAssignmentNode} from "./AST/ArithmeticAssignmentNode";
 import {UnitLiteralNode} from "./AST/UnitLiteralNode";
 import {BooleanLiteralNode} from "./AST/BooleanLiteralNode";
 import {NotNode} from "./AST/NotNode";
+import {XHRNode} from "./AST/XHRNode";
+import {StringFormatNode} from "./AST/StringFormatNode";
 
 function lower(str: string): string {
     return str ? str.toLowerCase() : null;
@@ -47,6 +49,7 @@ export enum BlockType {
 }
 
 export enum TokenType {
+    NULL,
     WHITESPACE,
     TYPE_INT,
     TYPE_UINT,
@@ -71,7 +74,8 @@ export enum TokenType {
     PERIOD,
     COMMA,
     COLON,
-    SEMI_COLON,
+    SEMICOLON,
+    STRING_FORMAT,
     STRING_LITERAL,
     NUMBER_LITERAL,
     BOOLEAN_LITERAL,
@@ -101,6 +105,10 @@ export enum TokenType {
     ELEMENT_STYLE,
     ELEMENT_QUERY,
     UNIT,
+    XHR_GET,
+    XHR_POST,
+    XHR_PUT,
+    XHR_DELETE,
 }
 
 const TOKEN_PATTERNS: TokenPattern[] = [
@@ -108,6 +116,22 @@ const TOKEN_PATTERNS: TokenPattern[] = [
         type: TokenType.WHITESPACE,
         pattern: /^[\s\n\r]+/
     },
+    {
+        type: TokenType.XHR_POST,
+        pattern: /^>>/
+    },
+    {
+        type: TokenType.XHR_PUT,
+        pattern: /^<>/
+    },
+    {
+        type: TokenType.XHR_GET,
+        pattern: /^<</
+    },
+    {
+        type: TokenType.XHR_DELETE,
+        pattern: /^></
+    },
     {
         type: TokenType.TYPE_INT,
         pattern: /^int+/
@@ -257,9 +281,13 @@ const TOKEN_PATTERNS: TokenPattern[] = [
         pattern: /^:/
     },
     {
-        type: TokenType.SEMI_COLON,
+        type: TokenType.SEMICOLON,
         pattern: /^;/
     },
+    {
+        type: TokenType.STRING_FORMAT,
+        pattern: /^`([^`]*)`/
+    },
     {
         type: TokenType.STRING_LITERAL,
         pattern: /^"([^"]*)"/
@@ -341,36 +369,38 @@ export const AttributableNodes = [
 
 export class Tree {
     protected static cache: { [key: string]: Node } = {};
-    protected rootNode: Node;
+    protected _root: Node;
 
     constructor(
         public readonly code: string
     ) {
         if (Tree.cache[code]) {
-            this.rootNode = Tree.cache[code];
+            this._root = Tree.cache[code];
         } else {
             this.parse();
-            Tree.cache[code] = this.rootNode;
+            Tree.cache[code] = this._root;
         }
     }
 
+    public get root(): Node { return this._root; }
+
     public parse() {
         const tokens = Tree.tokenize(this.code);
-        this.rootNode = Tree.processTokens(tokens);
+        this._root = Tree.processTokens(tokens);
     }
 
     async evaluate(scope: Scope, dom: DOM, tag: Tag = null) {
-        return await this.rootNode.evaluate(scope, dom, tag);
+        return await this._root.evaluate(scope, dom, tag);
     }
 
     async prepare(scope: Scope, dom: DOM, tag: Tag = null) {
-        if (!this.rootNode.isPreparationRequired())
+        if (!this._root.isPreparationRequired())
             return;
-        return await this.rootNode.prepare(scope, dom, tag);
+        return await this._root.prepare(scope, dom, tag);
     }
 
     async bindToScopeChanges(scope, fnc, dom: DOM, tag: Tag = null) {
-        for (const node of this.rootNode.findChildrenByTypes<ScopeMemberNode | ElementAttributeNode>([RootScopeMemberNode, ScopeMemberNode, ElementAttributeNode], 'ScopeMemberNodes')) {
+        for (const node of this._root.findChildrenByTypes<ScopeMemberNode | ElementAttributeNode>([RootScopeMemberNode, ScopeMemberNode, ElementAttributeNode], 'ScopeMemberNodes')) {
             let _scope: Scope = scope;
             if (node instanceof ScopeMemberNode)
                 _scope = await node.scope.evaluate(scope, dom);
@@ -431,14 +461,16 @@ export class Tree {
             if (count > 1000) break; // Limit to 1000 iterations while in development
 
             if (tokens[0].type === TokenType.RETURN)
-                tokens.splice(0, 1);
+                tokens.shift()
 
             const token: Token = tokens[0];
             if (token.type === TokenType.NAME) {
                 node = new RootScopeMemberNode<string>(
                     new LiteralNode<string>(token.value)
                 );
-                tokens.splice(0, 1);
+                tokens.shift()
+            } else if (XHRNode.match(tokens)) {
+                node = XHRNode.parse(node, tokens[0], tokens);
             } else if (token.type === TokenType.IF) {
                 node = IfStatementNode.parse(node, token, tokens);
                 blockNodes.push(node);
@@ -447,18 +479,20 @@ export class Tree {
                 node = ForStatementNode.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) {
                 node = new LiteralNode(token.value);
-                tokens.splice(0, 1);
+                tokens.shift()
             } else if (token.type === TokenType.NUMBER_LITERAL) {
                 node = new NumberLiteralNode(token.value);
-                tokens.splice(0, 1);
+                tokens.shift()
             } else if (tokens[0].type === TokenType.ELEMENT_REFERENCE) {
                 node = new ElementQueryNode(tokens[0].value, true);
-                tokens.splice(0, 1);
+                tokens.shift()
             } else if (tokens[0].type === TokenType.ELEMENT_QUERY) {
                 node = new ElementQueryNode(tokens[0].value);
-                tokens.splice(0, 1);
+                tokens.shift()
             } else if (tokens[0].type === TokenType.L_BRACKET) {
                 if (node) {
                     node = IndexNode.parse(node, token, tokens);
@@ -469,10 +503,10 @@ export class Tree {
                 node = ObjectNode.parse(node, token, tokens);
             } else if (tokens[0].type === TokenType.ELEMENT_ATTRIBUTE) {
                 node = new ElementAttributeNode(node as any, tokens[0].value);
-                tokens.splice(0, 1);
+                tokens.shift()
             } else if (tokens[0].type === TokenType.ELEMENT_STYLE) {
                 node = new ElementStyleNode(node as any, tokens[0].value);
-                tokens.splice(0, 1);
+                tokens.shift()
             } else if (node !== null && token.type === TokenType.PERIOD && tokens[1].type === TokenType.NAME) {
                 node = new ScopeMemberNode(
                     node,
@@ -493,12 +527,12 @@ export class Tree {
                 } else {
                     node = new BlockNode(nodes);
                 }
-            } else if (tokens[0].type === TokenType.SEMI_COLON) {
+            } else if (tokens[0].type === TokenType.SEMICOLON) {
                 if (node) {
                     blockNodes.push(node);
                 }
                 node = null;
-                tokens.splice(0, 1);
+                tokens.shift()
             } else if (InNode.match(tokens)) {
                 node = InNode.parse(node, token, tokens);
             } else if (ComparisonNode.match(tokens)) {
@@ -508,16 +542,16 @@ export class Tree {
             } else if (ArithmeticAssignmentNode.match(tokens)) {
                 node = ArithmeticAssignmentNode.parse(node, token, tokens);
             } else if (tokens[0].type === TokenType.WHITESPACE) {
-                tokens.splice(0, 1);
+                tokens.shift()
             } else if (tokens[0].type === TokenType.UNIT) {
                 node = new UnitLiteralNode(tokens[0].value);
-                tokens.splice(0, 1);
+                tokens.shift()
             } else if (tokens[0].type === TokenType.BOOLEAN_LITERAL) {
                 node = new BooleanLiteralNode(tokens[0].value);
-                tokens.splice(0, 1);
+                tokens.shift()
             } else if (tokens[0].type === TokenType.NULL_LITERAL) {
                 node = new LiteralNode(null);
-                tokens.splice(0, 1);
+                tokens.shift()
             } else if (tokens[0].type === TokenType.EXCLAMATION_POINT) {
                 node = NotNode.parse(node, tokens[0], tokens);
             } else {
@@ -583,7 +617,7 @@ export class Tree {
                 break;
             default:
                 open = null;
-                close = TokenType.SEMI_COLON;
+                close = TokenType.SEMICOLON;
                 openCharacter = null;
                 closeCharacter = ';';
                 break;
@@ -603,7 +637,7 @@ export class Tree {
 
         // Consume opening block token
         if (consumeOpeningToken && tokens[0].type === blockInfo.open) {
-            tokens.splice(0, 1);
+            tokens.shift()
         }
 
         return Tree.getTokensUntil(tokens, blockInfo.close, consumeClosingToken, includeClosingToken);
@@ -632,7 +666,7 @@ export class Tree {
             }
 
             // Consume token
-            tokens.splice(0, 1);
+            tokens.shift()
             i--;
             if (openBlocks === 0) {
                 if (arg.length > 0)
@@ -644,7 +678,7 @@ export class Tree {
         throw Error(`Invalid Syntax, missing ${blockInfo.closeCharacter}`);
     }
 
-    public static getTokensUntil(tokens: Token[], terminator: TokenType = TokenType.SEMI_COLON, consumeTerminator: boolean = true, includeTerminator: boolean = false, validIfTerminatorNotFound: boolean = false, blockInfo: IBlockInfo = null): Token[] {
+    public static getTokensUntil(tokens: Token[], terminator: TokenType = TokenType.SEMICOLON, consumeTerminator: boolean = true, includeTerminator: boolean = false, validIfTerminatorNotFound: boolean = false, blockInfo: IBlockInfo = null): Token[] {
         const statementTokens: Token[] = [];
         blockInfo = blockInfo || Tree.getBlockInfo(tokens);
 
@@ -681,8 +715,9 @@ export class Tree {
                     if (includeTerminator)
                         statementTokens.push(token);
 
-                    if ((includeTerminator || consumeTerminator) && token.type !== TokenType.SEMI_COLON)
-                        tokens.splice(0, 1); // Consume end of block
+                    //if (consumeTerminator && token.type !== TokenType.SEMICOLON)
+                    if ((includeTerminator || consumeTerminator) && token.type !== TokenType.SEMICOLON)
+                        tokens.shift() // Consume end of block
                     break;
                 } else if (token.type === terminator && (openParens > 0 || openBraces > 0 || openBrackets > 0)) {
                 } else {
@@ -693,7 +728,7 @@ export class Tree {
             }
 
             statementTokens.push(token);
-            tokens.splice(0, 1); // Consume part of statement
+            tokens.shift() // Consume part of statement
             i--;
         }
         return statementTokens;

package/src/DOM/DOMObject.ts

@@ -31,4 +31,10 @@ export abstract class DOMObject extends EventDispatcher {
     public watchStyle(style: string) {
 
     }
+
+    public deconstruct() {
+        if (this._uniqueScope)
+            this.scope?.deconstruct();
+        super.deconstruct();
+    }
 }