vsn 0.1.148 → 1.0.0

package/src/AST/Node.ts

@@ -1,104 +0,0 @@
-import {Scope} from "../Scope";
-import {DOM} from "../DOM";
-import {Tag, TagState} from "../Tag";
-import {Token, TokenType, TreeNode} from "../AST";
-import {Modifiers} from "../Modifiers";
-
-export interface INodeMeta {
-    [key: string]: string | number | boolean | null;
-}
-
-export abstract class Node implements TreeNode {
-    protected requiresPrep: boolean = false;
-    protected _isPreparationRequired: boolean;
-    protected childNodes: Node[];
-    protected nodeCache: {[key: string]: Node[]} = {};
-    public readonly modifiers: Modifiers = new Modifiers();
-
-    async evaluate(scope: Scope, dom: DOM, tag?: Tag): Promise<any> {
-        if (scope.isGarbage || (tag && tag.state === TagState.Deconstructed))
-            return;
-        return await this._evaluate(scope, dom, tag);
-    }
-
-    protected async _evaluate(scope: Scope, dom: DOM, tag?: Tag): Promise<any> {}
-
-    isPreparationRequired(): boolean {
-        if (this.requiresPrep)
-            return true;
-
-        if (this._isPreparationRequired !== undefined)
-            return this._isPreparationRequired;
-
-        for (const node of this.getChildNodes()) {
-            if (node.isPreparationRequired()) {
-                this._isPreparationRequired = true;
-                return true;
-            }
-        }
-
-        return false;
-    }
-
-    async prepare(scope: Scope, dom: DOM, tag: Tag = null, meta: INodeMeta = null): Promise<void> {
-        for (const node of this.getChildNodes()) {
-            await node.prepare(scope, dom, tag, meta);
-        }
-    }
-
-    async cleanup(scope: Scope, dom: DOM, tag: Tag) {
-        for (const node of this.getChildNodes()) {
-            await node.cleanup(scope, dom, tag);
-        }
-    }
-
-    protected _getChildNodes(): Node[] {
-        return [];
-    }
-
-    getChildNodes(): Node[] {
-        if (this.childNodes === undefined) {
-            this.childNodes = this._getChildNodes();
-        }
-        return this.childNodes;
-    }
-
-    findChildrenByType<T = Node>(t: any): T[] {
-        return this.findChildrenByTypes([t]);
-    }
-
-    findChildrenByTypes<T = Node>(types: any[], cacheKey: string = null): T[] {
-        if (cacheKey !== null && this.nodeCache[cacheKey])
-            return this.nodeCache[cacheKey] as any;
-
-        const nodes: T[] = [];
-        for (const child of this.getChildNodes()) {
-            for (const t of types) {
-                if (child instanceof t)
-                    nodes.push(child as any as T);
-                const childNodes: T[] = child.findChildrenByType<T>(t);
-                nodes.push(...childNodes);
-            }
-        }
-
-        if (cacheKey !== null)
-            this.nodeCache[cacheKey] = nodes as any;
-
-        return nodes;
-    }
-
-    hasModifier(modifier: string): boolean {
-        return this.modifiers.has(modifier);
-    }
-
-    public static moveModifiers(from: Token[], to: Token[] = null): Token[] {
-        to = to || [];
-        if (from && from.length) {
-            while (from[0] && from[0].type == TokenType.MODIFIER) {
-                to.unshift(from.shift());
-            }
-        }
-        return to;
-    }
-}
-

package/src/AST/NotNode.ts

@@ -1,41 +0,0 @@
-import {Scope} from "../Scope";
-import {DOM} from "../DOM";
-import {Tag} from "../Tag";
-import {Token, TokenType, Tree, TreeNode} from "../AST";
-import {Node} from "./Node";
-
-export class NotNode extends Node implements TreeNode {
-    constructor(
-        public readonly toFlip: Node
-    ) {
-        super();
-    }
-
-    protected async _evaluate(scope: Scope, dom: DOM, tag: Tag = null) {
-        const flipping = await this.toFlip.evaluate(scope, dom, tag);
-        return !flipping;
-    }
-
-    protected _getChildNodes(): Node[] {
-        return [
-            this.toFlip
-        ];
-    }
-
-    public static parse(lastNode, token, tokens: Token[]) {
-        tokens.splice(0, 1); // Remove not operator
-        let containedTokens;
-        if (tokens[0].type === TokenType.L_PAREN) {
-            containedTokens = Tree.getNextStatementTokens(tokens);
-        } else {
-            containedTokens = Tree.consumeTypes(tokens, [
-                TokenType.BOOLEAN_LITERAL,
-                TokenType.NUMBER_LITERAL,
-                TokenType.STRING_LITERAL,
-                TokenType.NAME,
-                TokenType.PERIOD
-            ]);
-        }
-        return new NotNode(Tree.processTokens(containedTokens));
-    }
-}

package/src/AST/NumberLiteralNode.ts

@@ -1,14 +0,0 @@
-import {LiteralNode} from "./LiteralNode";
-
-export class NumberLiteralNode extends LiteralNode<number> {
-    constructor(
-        public readonly value: any
-    ) {
-        super(value);
-        if (this.value.indexOf('.') > -1) {
-            this.value = parseFloat(this.value)
-        } else {
-            this.value = parseInt(this.value);
-        }
-    }
-}

package/src/AST/ObjectNode.ts

@@ -1,55 +0,0 @@
-import {Scope} from "../Scope";
-import {DOM} from "../DOM";
-import {Tag} from "../Tag";
-import {BlockType, Token, TokenType, Tree, TreeNode} from "../AST";
-import {Node} from "./Node";
-
-export class ObjectNode extends Node implements TreeNode {
-    constructor(
-        public readonly keys: Node[],
-        public readonly values: Node[]
-    ) {
-        super();
-    }
-
-    protected _getChildNodes(): Node[] {
-        return new Array(...this.values);
-    }
-
-    protected async _evaluate(scope: Scope, dom: DOM, tag: Tag = null) {
-        const obj: Scope = new Scope();
-        for (let i = 0; i < this.values.length; i++) {
-            const key = this.keys[i];
-            const val = this.values[i];
-            obj.set(await key.evaluate(scope, dom, tag), await val.evaluate(scope, dom, tag), true);
-        }
-        return obj;
-    }
-
-    public static match(tokens: Token[]): boolean {
-        return tokens[0].type === TokenType.L_BRACE;
-    }
-
-    public static parse(lastNode, token, tokens: Token[]): ObjectNode {
-        const valueTokens: Token[] = Tree.getNextStatementTokens(tokens);
-        const keys: Node[] = [];
-        const values: Node[] = [];
-
-        while (valueTokens.length > 0) {
-            const key: Token[] = Tree.getTokensUntil(valueTokens, TokenType.COLON, false);
-            if (valueTokens[0].type !== TokenType.COLON)
-                throw Error('Invalid object literal syntax. Expecting :');
-            valueTokens.splice(0, 1); // Consume :
-            const val: Token[] = Tree.getTokensUntil(valueTokens, TokenType.COMMA, true, false, true, {
-                type: BlockType.STATEMENT,
-                open: null,
-                close: null,
-                openCharacter: null,
-                closeCharacter: null
-            });
-            keys.push(Tree.processTokens(key));
-            values.push(Tree.processTokens(val));
-        }
-        return new ObjectNode(keys, values);
-    }
-}

package/src/AST/OnNode.ts

@@ -1,23 +0,0 @@
-import {Token, TreeNode} from "../AST";
-import {FunctionNode} from "./FunctionNode";
-import {Scope} from "../Scope";
-import {DOM} from "../DOM";
-import {Tag} from "../Tag";
-
-export class OnNode extends FunctionNode implements TreeNode {
-    public async prepare(scope: Scope, dom: DOM, tag: Tag = null, meta): Promise<void> {
-        const classPrep = meta?.ClassNodePrepare; // Don't add event handler if we're in class prep
-        if (tag && !classPrep) {
-            const func = await this.getFunction(scope, dom, tag);
-            tag.addEventHandler(this.name, this.modifiers, async (...args) => {
-                await func(...args);
-                await this.collectGarbage();
-            }, this);
-        }
-        await super.prepare(scope, dom, tag, meta);
-    }
-
-    public static parse<T = OnNode>(lastNode, token, tokens: Token[]): T {
-        return super.parse<T>(lastNode, token, tokens, OnNode);
-    }
-}

package/src/AST/RootScopeMemberNode.ts

@@ -1,27 +0,0 @@
-import {Scope} from "../Scope";
-import {DOM} from "../DOM";
-import {Tag} from "../Tag";
-import {TreeNode} from "../AST";
-import {Node} from "./Node";
-import {ScopeNodeAbstract} from "./ScopeNodeAbstract";
-
-export class RootScopeMemberNode<T = any> extends ScopeNodeAbstract implements TreeNode {
-    constructor(
-        public readonly name: TreeNode<string>
-    ) {
-        super();
-    }
-
-    protected _getChildNodes(): Node[] {
-        return [
-            this.name as Node
-        ]
-    }
-
-    protected async _evaluate(scope: Scope, dom: DOM, tag: Tag = null) {
-        const name = await this.name.evaluate(scope, dom, tag);
-        await this.applyModifiers(name, scope, dom, tag);
-        const value = scope.get(name);
-        return value instanceof Scope && value.wrapped || value;
-    }
-}

package/src/AST/ScopeMemberNode.ts

@@ -1,63 +0,0 @@
-import {Scope} from "../Scope";
-import {DOM} from "../DOM";
-import {Tag} from "../Tag";
-import {TagList} from "../Tag/TagList";
-import {DOMObject} from "../DOM/DOMObject";
-import {TreeNode} from "../AST";
-import {Node} from "./Node";
-import {ElementQueryNode} from "./ElementQueryNode";
-import {ScopeNodeAbstract} from "./ScopeNodeAbstract";
-import {ObjectAccessor} from "../Scope/ObjectAccessor";
-import {ScopeAbstract} from "../Scope/ScopeAbstract";
-
-export class ScopeMemberNode extends ScopeNodeAbstract implements TreeNode {
-    constructor(
-        public readonly scope: TreeNode<Scope>,
-        public readonly name: TreeNode<string>
-    ) {
-        super();
-    }
-
-    protected _getChildNodes(): Node[] {
-        return [
-            this.scope as Node,
-            this.name as Node
-        ]
-    }
-
-    protected async _evaluate(scope: Scope, dom: DOM, tag: Tag = null) {
-        let scopes = [];
-        const values = [];
-        if (this.scope instanceof ElementQueryNode) {
-            const elements = await this.scope.evaluate(scope, dom, tag);
-            if (this.scope.first) {
-                scopes.push(elements);
-            } else {
-                scopes = elements;
-            }
-        } else {
-            const evalScope = await this.scope.evaluate(scope, dom, tag);
-            if (evalScope instanceof TagList) {
-                scopes = evalScope;
-            } else {
-                scopes.push(evalScope);
-            }
-        }
-
-        for (let parent of scopes) {
-            if (parent instanceof DOMObject)
-                parent = parent.scope;
-            else if (parent && !(parent instanceof ScopeAbstract))
-                parent = new ObjectAccessor(parent);
-
-            if (!parent) {
-                throw Error(`Cannot access "${await this.name.evaluate(scope, dom, tag)}" of undefined.`);
-            }
-            const name = await this.name.evaluate(scope, dom, tag);
-            await this.applyModifiers(name, parent, dom, tag);
-            const value: any = parent.get(name, false);
-            values.push(value instanceof Scope && value.wrapped || value);
-        }
-        return values.length === 1 ? values[0] : values;
-    }
-}

package/src/AST/ScopeNodeAbstract.ts

@@ -1,21 +0,0 @@
-import {Node} from "./Node";
-import {TreeNode} from "../AST";
-import {Scope} from "../Scope";
-import {DOM} from "../DOM";
-import {Tag} from "../Tag";
-import {Registry} from "../Registry";
-
-export abstract class ScopeNodeAbstract extends Node implements TreeNode {
-    async applyModifiers(name: string, scope: Scope, dom: DOM, tag: Tag) {
-        let type: string;
-        for (const modifier of this.modifiers.iter) {
-            // Check for type cast modifier
-            if (Registry.instance.types.has(modifier.name)) {
-                type = modifier.name;
-                break;
-            }
-        }
-        if (type && scope instanceof Scope)
-            scope.setType(name, type);
-    }
-}

package/src/AST/StringFormatNode.ts

@@ -1,43 +0,0 @@
-import {Node} from "./Node";
-import {Token, TokenType, Tree, TreeNode} from "../AST";
-import {Scope} from "../Scope";
-import {DOM} from "../DOM";
-import {Tag} from "../Tag";
-
-export class StringFormatNode extends Node implements TreeNode {
-    constructor(
-        public readonly segments: {[key:string]: Node},
-        public readonly value: string
-    ) {
-        super();
-    }
-
-    public getChildNodes(): Node[] {
-        return this.segments && Object.values(this.segments) || [];
-    }
-
-    protected async _evaluate(scope: Scope, dom: DOM, tag?: Tag) {
-        let value = this.value;
-        for (const key in this.segments) {
-            const segment = this.segments[key];
-            const segmentValue = await segment.evaluate(scope, dom, tag);
-            value = value.replace(`\${${key}}`, segmentValue);
-        }
-        return value;
-    }
-
-    public static parse(node: Node, token: Token, tokens: Token[]): StringFormatNode {
-        const segments = {};
-        for (const segment of Array.from(new Set(token.value.match(/\$\{([^}]+)}/g)))) {
-            const [, code] = segment.split(/\$\{|}/);
-            const tree = new Tree(code);
-            segments[code] = tree.root;
-        }
-        tokens.shift();
-        return new StringFormatNode(segments, token.value);
-    }
-
-    public static match(tokens: Token[]) {
-        return tokens[0].type === TokenType.STRING_FORMAT;
-    }
-}

package/src/AST/UnitLiteralNode.ts

@@ -1,51 +0,0 @@
-import {LiteralNode} from "./LiteralNode";
-
-export class UnitLiteral {
-    protected _amount: number;
-    protected _unit: string;
-
-    constructor(
-        protected _value: any
-    ) {
-        this.value = this._value;
-    }
-
-    get amount(): number {
-        return this._amount;
-    }
-
-    get unit(): string {
-        return this._unit;
-    }
-
-    get value(): string {
-        return `${this._amount}${this._unit}`;
-    }
-
-    set value(value: string) {
-        if (value.indexOf('.') > -1) {
-            this._amount = parseFloat(value)
-        } else {
-            this._amount = parseInt(value);
-        }
-
-        if (isNaN(this._amount))
-            this._amount = 0;
-
-        const unit = /[^\d.]+$/.exec(value);
-        this._unit = unit && unit[0] || '';
-    }
-
-    public toString() {
-        return this.value;
-    }
-}
-
-
-export class UnitLiteralNode extends LiteralNode<UnitLiteral> {
-    constructor(
-        _value: any
-    ) {
-        super(new UnitLiteral(_value));
-    }
-}

package/src/AST/WASM/Context.ts

@@ -1,12 +0,0 @@
-
-export class WASMContext {
-    public readonly names: string[];
-    public addName(name: string): number {
-        let index: number = this.names.indexOf(name);
-        if (index == -1) {
-            index = this.names.length;
-            this.names.push(name);
-        }
-        return index;
-    }
-}

package/src/AST/WASM/Function.ts

@@ -1,67 +0,0 @@
-import {EExportType, encodeString, encodeVector, EValueType, functionType} from "../WASM";
-import {Section} from "./Section";
-
-export class FunctionSection extends Section {
-    protected readonly variables: {[key: string]: number} = {};
-    protected readonly params: EValueType[] = [];
-    protected readonly results: EValueType[] = [];
-    protected readonly code: number[] = [];
-
-    constructor(
-        protected readonly name: string
-    ) {
-        super();
-    }
-
-    public addParam(paramType: EValueType, name: string = null) {
-        const index: number = this.params.length;
-        name = name || `$param${index}`;
-        this.variables[name] = index;
-        this.params.push(paramType);
-    }
-
-    public addResult(paramType: EValueType) {
-        this.results.push(paramType);
-    }
-
-    public addCode(code: number[]) {
-        this.code.push(...code);
-    }
-
-    get sectionTypes(): number[] {
-        return [
-            functionType,
-            this.paramCount, // Number of params
-            ...this.paramTypes, // Param type(s)
-            this.resultCount, // Number of results
-            ...this.resultTypes, // result type(s)
-        ];
-    }
-
-    get sectionExport(): number[] {
-        return [
-            ...encodeString(this.name),
-            EExportType.func,
-        ]
-    }
-
-    get sectionCode(): number[] {
-        return encodeVector(this.code);
-    }
-
-    get paramCount(): number {
-        return this.params.length;
-    }
-
-    get paramTypes(): number[] {
-        return this.params;
-    }
-
-    get resultCount(): number {
-        return this.results.length;
-    }
-
-    get resultTypes(): number[] {
-        return this.results;
-    }
-}

package/src/AST/WASM/Memory.ts

@@ -1,21 +0,0 @@
-import {EValueType} from "../WASM";
-import {FunctionSection} from "./Function";
-
-export enum EMemoryType {
-    i32,
-    i64,
-    f32,
-    f64,
-    i32Array,
-    i64Array,
-    f32Array,
-    f64Array
-}
-
-export const memoryVariableIndex = new FunctionSection("memoryVariableIndex");
-memoryVariableIndex.addParam(EValueType.i32);
-memoryVariableIndex.addParam(EValueType.i32);
-memoryVariableIndex.addResult(EValueType.i32);
-memoryVariableIndex.addCode([
-
-]);

package/src/AST/WASM/Section.ts

@@ -1,6 +0,0 @@
-
-export abstract class Section {
-    public readonly fYeah = true;
-    abstract get sectionTypes(): number[];
-    abstract get sectionExport(): number[];
-}