vsn 0.1.148 → 1.0.0

package/src/AST/ClassNode.ts

@@ -1,267 +0,0 @@
-import {Scope} from "../Scope";
-import {DOM} from "../DOM";
-import {Tag} from "../Tag";
-import {Token, TokenType, Tree, TreeNode} from "../AST";
-import {INodeMeta, Node} from "./Node";
-import {BlockNode} from "./BlockNode";
-import {Registry} from "../Registry";
-import {OnNode} from "./OnNode";
-import {FunctionNode} from "./FunctionNode";
-
-export class ClassNode extends Node implements TreeNode {
-    public static readonly ClassesVariable = '_vsn_classes';
-    public static readonly classes: {[name: string]: ClassNode} = {};
-    public static readonly classParents: {[name: string]: string[]} = {};
-    public static readonly classChildren: {[name: string]: string[]} = {}; // List of child class selectors for a given class selector
-    public static readonly preppedTags: {[name: string]: Tag[]} = {};
-    public static readonly preppingElements: {[name: string]: HTMLElement[]} = {};
-
-    protected requiresPrep: boolean = true;
-    public readonly classScope: Scope = new Scope();
-    protected _fullSelector: string;
-    protected _parentSelector: string;
-
-    constructor(
-        public readonly selector: string,
-        public readonly block: BlockNode
-    ) {
-        super();
-    }
-
-    public get fullSelector(): string {
-        return this._fullSelector;
-    }
-
-    public updateMeta(meta?: any) {
-        meta = meta || {};
-        meta['ClassNode'] = this;
-        return meta;
-    }
-
-    public async prepare(scope: Scope, dom: DOM, tag: Tag = null, meta?: INodeMeta): Promise<void> {
-        meta = Object.assign({}, meta) || {};
-        const initial = !!meta['initial'];
-        let root: boolean = false;
-        meta['ClassNodePrepare'] = initial;
-
-        // Only prepare once during the initial prep, all subsequent prepares are on tag class blocks
-        if (initial) {
-            if (meta['ClassNodeSelector']) {
-                this._parentSelector = meta['ClassNodeSelector'] as string;
-                ClassNode.classChildren[meta['ClassNodeSelector'] as string].push(this.selector);
-                meta['ClassNodeSelector'] = `${meta['ClassNodeSelector']} ${this.selector}`;
-            } else {
-                root = true;
-                meta['ClassNodeSelector'] = this.selector;
-            }
-
-            this._fullSelector = meta['ClassNodeSelector'];
-            if (ClassNode.classes[this._fullSelector]) return; // Don't re-prepare same classes
-            ClassNode.classes[this._fullSelector] = this;
-            ClassNode.classChildren[this._fullSelector] = [];
-            ClassNode.preppedTags[this._fullSelector] = [];
-            ClassNode.preppingElements[this._fullSelector] = []
-
-            if (ClassNode.classParents[this.selector] === undefined)
-                ClassNode.classParents[this.selector] = [];
-
-            ClassNode.classParents[this.selector].push(this._fullSelector);
-            await this.block.prepare(this.classScope, dom, tag, meta);
-            Registry.class(this);
-
-            if (root) {
-                if (dom.built)
-                    await this.findClassElements(dom);
-                dom.on('built', () => this.findClassElements(dom));
-            }
-        } else if (meta['PrepForSelector'] === this.fullSelector) { // Only prepare top level class if we're prepping for tag
-            await this.block.prepare(tag.scope, dom, tag, meta);
-        }
-    }
-
-    public async findClassElements(dom: DOM, tag: Tag = null) {
-        const tags: Tag[] = [];
-        for (const element of Array.from(dom.querySelectorAll(this.fullSelector, tag))) {
-            if (ClassNode.preppingElements[this._fullSelector].indexOf(element as HTMLElement) > -1) continue;
-            ClassNode.preppingElements[this._fullSelector].push(element as HTMLElement);
-            tags.push(await ClassNode.addElementClass(this._fullSelector, element as HTMLElement, dom, element[Tag.TaggedVariable] || null));
-            ClassNode.preppingElements[this._fullSelector].splice(ClassNode.preppingElements[this._fullSelector].indexOf(element as HTMLElement), 1);
-        }
-
-        for (const childSelector of ClassNode.classChildren[this._fullSelector]) {
-            const node =  ClassNode.classes[`${this._fullSelector} ${childSelector}`];
-            if (!node) continue;
-            for (const _tag of tags) {
-                await node.findClassElements(dom, _tag);
-            }
-        }
-    }
-
-    public async constructTag(tag: Tag, dom: DOM, hasConstruct: boolean | null = null) {
-        if (ClassNode.preppedTags[this.fullSelector].indexOf(tag) !== -1) {
-            return;
-        }
-        ClassNode.preppedTags[this.fullSelector].push(tag);
-        tag.once('deconstruct', (_tag) => {
-            const index = ClassNode.preppedTags[this.fullSelector].indexOf(_tag);
-            if (index > -1)
-                ClassNode.preppedTags[this.fullSelector].splice(index, 1);
-        });
-
-        if (hasConstruct === null)
-            hasConstruct = this.classScope.has('construct');
-
-        tag.createScope(true);
-        const meta = this.updateMeta();
-        meta['PrepForSelector'] = this.fullSelector;
-        await this.block.prepare(tag.scope, dom, tag, meta);
-        if (hasConstruct) {
-            const fncCls: FunctionNode = this.classScope.get('construct') as FunctionNode;
-            const fnc = await fncCls.getFunction(tag.scope, dom, tag, true);
-            await fnc();
-            await fncCls.collectGarbage();
-        }
-        tag.dispatch(`${this.fullSelector}.construct`, tag.element.id);
-        ClassNode.addPreparedClassToElement(tag.element, this.fullSelector);
-    }
-
-    public async deconstructTag(tag: Tag, dom: DOM, hasDeconstruct: boolean | null = null) {
-        if (hasDeconstruct === null)
-            hasDeconstruct = this.classScope.has('deconstruct');
-
-        if (hasDeconstruct) {
-            const fncCls: FunctionNode = this.classScope.get('deconstruct') as FunctionNode;
-            const fnc = await fncCls.getFunction(tag.scope, dom, tag, true);
-            await fnc();
-            await fncCls.collectGarbage();
-        }
-        for (const key of this.classScope.keys) {
-            if (this.classScope.get(key) instanceof OnNode) {
-                const on = this.classScope.get(key) as OnNode;
-                tag.removeContextEventHandlers(on);
-            }
-        }
-        tag.dispatch(`${this.fullSelector}.deconstruct`);
-        ClassNode.preppedTags[this.fullSelector].splice(ClassNode.preppedTags[this.fullSelector].indexOf(tag), 1);
-        ClassNode.removePreparedClassFromElement(tag.element, this.fullSelector);
-    }
-
-    protected async _evaluate(scope: Scope, dom: DOM, tag: Tag = null) {
-        return null;
-    }
-
-    public static parse(lastNode, token, tokens: Token[]): ClassNode {
-        let selector = tokens.shift().value;
-        if (selector.startsWith('>'))
-            selector = `:scope ${selector}`;
-        const block = Tree.processTokens(Tree.getNextStatementTokens(tokens, true, true));
-        return new ClassNode(selector.trim(), block);
-    }
-
-    public getSelectorPath(): string[] {
-        const path: string[] = [this.selector];
-        let current = this._parentSelector;
-        while (current) {
-            path.push(ClassNode.classes[current].selector);
-            current = ClassNode.classes[current]._parentSelector;
-        }
-        return path.reverse();
-    }
-
-    public static async checkForClassChanges(element: HTMLElement, dom: DOM, tag: Tag = null) {
-        const localSelectors: string[] = [element.tagName.toLowerCase(), ...Array.from(element.classList).map(c => `.${c}`)];
-        const fullSelectors: string[] = [...ClassNode.getClassesForElement(element)];
-        if (element.id)
-            localSelectors.push(`#${element.id}`);
-
-        for (const selector of localSelectors) {
-            const parentSelectors = ClassNode.classParents[selector];
-            if (parentSelectors) {
-                fullSelectors.push(...parentSelectors.filter(s => !fullSelectors.includes(s)));
-            }
-        }
-
-        if (!tag) {
-            tag = await dom.getTagForElement(element, true);
-        }
-
-        for (const selector of fullSelectors) {
-            const isPrepped = ClassNode.getClassesForElement(element).includes(selector);
-            const path = ClassNode.classes[selector]?.getSelectorPath();
-            const elements = dom.querySelectPath(path);
-            const inElements = elements.includes(element);
-            let changed: boolean = false;
-
-            if (inElements && !isPrepped) {
-                await ClassNode.addElementClass(selector, element, dom, tag);
-                changed = true;
-            } else if (!inElements && isPrepped) {
-                await ClassNode.removeElementClass(selector, element, dom, tag);
-                changed = true;
-            }
-
-            if (changed && ClassNode.classChildren[selector].length > 0) {
-                for (const childSelector of ClassNode.classChildren[selector]) {
-                    for (const childElement of Array.from(dom.querySelectorAll(childSelector, tag)) as HTMLElement[]) {
-                        await ClassNode.checkForClassChanges(childElement, dom, childElement[Tag.TaggedVariable] || null);
-                    }
-                }
-            }
-
-        }
-    }
-
-    public static getClassesForElement(element: HTMLElement): string[] {
-        if (!element[ClassNode.ClassesVariable])
-            element[ClassNode.ClassesVariable] = [];
-        return element[ClassNode.ClassesVariable];
-    }
-
-    public static addPreparedClassToElement(element: HTMLElement, selector: string) {
-        ClassNode.getClassesForElement(element).push(selector);
-    }
-
-    public static removePreparedClassFromElement(element: HTMLElement, selector: string) {
-        const classes = ClassNode.getClassesForElement(element);
-        classes.splice(classes.indexOf(selector), 1);
-    }
-
-    public static async addElementClass(selector: string, element: HTMLElement, dom: DOM, tag: Tag = null) {
-        const classes = ClassNode.getClassesForElement(element);
-        if (classes.includes(selector)) return;
-
-        if (!tag) {
-            tag = await dom.getTagForElement(element, true);
-        }
-
-        if (!tag) {
-            console.error('no tag found for element', element);
-            return;
-        }
-
-        const classNode: ClassNode = Registry.instance.classes.getSynchronous(selector);
-        if (classNode) {
-            await classNode.constructTag(tag, dom);
-        }
-
-        return tag;
-    }
-
-    public static async removeElementClass(selector: string, element: HTMLElement, dom: DOM, tag: Tag = null) {
-        const classes = ClassNode.getClassesForElement(element);
-        if (!classes.includes(selector)) return;
-
-        if (!tag) {
-            tag = await dom.getTagForElement(element, true);
-        }
-
-        const classNode: ClassNode = Registry.instance.classes.getSynchronous(selector);
-        if (classNode) {
-            await classNode.deconstructTag(tag, dom);
-        }
-    }
-
-    public static isClass(cls: string): boolean {
-        return !!this.classes[cls];
-    }
-}

package/src/AST/ComparisonNode.ts

@@ -1,57 +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 ComparisonNode extends Node implements TreeNode {
-    constructor(
-        public readonly left: Node,
-        public readonly right: Node,
-        public readonly type: TokenType
-    ) {
-        super();
-    }
-
-    protected _getChildNodes(): Node[] {
-        return [
-            this.left as Node,
-            this.right as Node
-        ];
-    }
-
-    protected async _evaluate(scope: Scope, dom: DOM, tag: Tag = null) {
-        const left: any = await this.left.evaluate(scope, dom, tag);
-        const right: any = await this.right.evaluate(scope, dom, tag);
-        switch (this.type) {
-            case TokenType.EQUALS:
-                return left === right;
-            case TokenType.NOT_EQUALS:
-                return left !== right;
-            case TokenType.GREATER_THAN:
-                return left > right;
-            case TokenType.LESS_THAN:
-                return left < right;
-            case TokenType.GREATER_THAN_EQUAL:
-                return left >= right;
-            case TokenType.LESS_THAN_EQUAL:
-                return left <= right;
-        }
-    }
-
-    public static match(tokens: Token[]): boolean {
-        return [
-            TokenType.EQUALS,
-            TokenType.NOT_EQUALS,
-            TokenType.GREATER_THAN,
-            TokenType.LESS_THAN,
-            TokenType.GREATER_THAN_EQUAL,
-            TokenType.LESS_THAN_EQUAL
-        ].indexOf(tokens[0].type) > -1
-    }
-
-    public static parse(lastNode, token, tokens: Token[]) {
-        tokens.splice(0, 1); // Remove comparison operator
-        return new ComparisonNode(lastNode, Tree.processTokens(Tree.getNextStatementTokens(tokens)), token.type)
-    }
-}

package/src/AST/ConditionalNode.ts

@@ -1,36 +0,0 @@
-import {Scope} from "../Scope";
-import {DOM} from "../DOM";
-import {Tag} from "../Tag";
-import {WrappedArray} from "../Scope/WrappedArray";
-import {TreeNode} from "../AST";
-import {BlockNode} from "./BlockNode";
-import {Node} from "./Node";
-
-export class ConditionalNode extends Node implements TreeNode {
-    constructor(
-        public readonly condition: Node,
-        public readonly block: BlockNode
-    ) {
-        super();
-    }
-
-    protected _getChildNodes(): Node[] {
-        return [
-            this.condition as Node,
-            this.block as Node
-        ];
-    }
-
-    protected async _evaluate(scope: Scope, dom: DOM, tag: Tag = null) {
-        const condition = await this.condition.evaluate(scope, dom, tag);
-        let evaluation = false;
-
-        if (condition instanceof WrappedArray) {
-            evaluation = condition.length > 0;
-        } else {
-            evaluation = !!condition;
-        }
-
-        return evaluation;
-    }
-}

package/src/AST/DispatchEventNode.ts

@@ -1,58 +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";
-import {ObjectNode} from "./ObjectNode";
-import {ScopeData} from "../Scope/ScopeData";
-import {ElementQueryNode} from "./ElementQueryNode";
-
-export class DispatchEventNode extends Node implements TreeNode {
-    constructor(
-        public readonly name: string,
-        public readonly data: ObjectNode | null,
-        public readonly bubbles: boolean = false,
-        public readonly elementRef: ElementQueryNode | null,
-    ) {
-        super();
-    }
-
-    protected _getChildNodes(): Node[] {
-        const nodes: Node[] = [];
-        if (this.data)
-            nodes.push(this.data);
-        return nodes;
-    }
-
-    protected async _evaluate(scope: Scope, dom: DOM, tag: Tag = null) {
-        let detail = this.data ? (await this.data.evaluate(scope, dom, tag)).objectify : {};
-        if (detail instanceof Scope)
-            detail = detail.data.getData();
-        else if (detail instanceof ScopeData)
-            detail = detail.getData();
-
-        let targets: Tag[] = [tag];
-        if (this.elementRef) {
-            targets = await this.elementRef.evaluate(scope, dom, tag, true);
-        }
-
-        for (const target of targets) {
-            detail['source'] = target.element;
-            target.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_BRACE) {
-            const containedTokens = Tree.getNextStatementTokens(tokens, false, false, true);
-            data = Tree.processTokens(containedTokens).statements[0] as ObjectNode;
-        }
-        const elementRef = lastNode instanceof ElementQueryNode ? lastNode : null;
-        return new DispatchEventNode(name.value, data, name.full.startsWith('!!!'), elementRef);
-    }
-}

package/src/AST/ElementAttributeNode.ts

@@ -1,97 +0,0 @@
-import {Scope} from "../Scope";
-import {DOM} from "../DOM";
-import {Tag} from "../Tag";
-import {TagList} from "../Tag/TagList";
-import {TreeNode} from "../AST";
-import {Node} from "./Node";
-import {ElementQueryNode} from "./ElementQueryNode";
-import {LiteralNode} from "./LiteralNode";
-import {DOMObject} from "../DOM/DOMObject";
-import {IndexNode} from "./IndexNode";
-import {ScopeMemberNode} from "./ScopeMemberNode";
-import {RootScopeMemberNode} from "./RootScopeMemberNode";
-
-export class ElementAttributeNode extends Node implements TreeNode {
-    protected requiresPrep: boolean = true;
-
-    constructor(
-        public readonly elementRef: ElementQueryNode | null,
-        public readonly attr: string
-    ) {
-        super();
-    }
-
-    public get name(): LiteralNode<string> {
-        return new LiteralNode<string>(`@${this.attributeName}`);
-    }
-
-    protected _getChildNodes(): Node[] {
-        let nodes = [];
-        if (this.elementRef)
-            nodes.push(this.elementRef)
-        return nodes;
-    }
-
-    get attributeName(): string {
-        if (this.attr.startsWith('.'))
-            return this.attr.substring(2);
-        return this.attr.substring(1);
-    }
-
-    protected async _evaluate(scope: Scope, dom: DOM, tag: Tag = null) {
-        let tags: TagList;
-
-        if (this.elementRef instanceof ElementQueryNode) {
-            tags = await this.elementRef.evaluate(scope, dom, tag, true);
-        } else if (this.elementRef as any instanceof IndexNode) {
-            const indexResult = await (this.elementRef as any).evaluate(scope, dom, tag, true);
-            if (indexResult instanceof TagList) {
-                tags = indexResult;
-            } else {
-                tags = new TagList(indexResult);
-            }
-        } else if (this.elementRef as any instanceof ScopeMemberNode || this.elementRef as any instanceof RootScopeMemberNode) {
-            const scopeEval = await (this.elementRef as any).evaluate(scope, dom, tag, true);
-            if (Array.isArray(scopeEval)) {
-                tags = scopeEval as any;
-            } else {
-                tags = new TagList(scopeEval);
-            }
-        } else if (tag) {
-            tags = new TagList(tag)
-        } else {
-            return;
-        }
-
-        if (tags.length === 1) {
-            return this.getAttributeScopeValue(tags[0]);
-        }
-
-        return tags.map((tag) => this.getAttributeScopeValue(tag));
-    }
-
-    async getAttributeScopeValue(tag: Tag | DOMObject): Promise<string> {
-        if (!(tag instanceof DOMObject)) {
-            return '';
-        }
-
-        // Make sure the attribute is being watched
-        await tag.watchAttribute(this.attributeName);
-        return tag.scope.get(`@${this.attributeName}`) as string;
-    }
-
-    async prepare(scope: Scope, dom: DOM, tag: Tag = null, meta: any = null) {
-        if (this.elementRef) {
-            await this.elementRef.prepare(scope, dom, tag, meta);
-            const tags: any = await this.elementRef.evaluate(scope, dom, tag, true);
-            if (tags instanceof TagList) {
-                for (const t of tags)
-                    await t?.watchAttribute(this.attributeName);
-            } else if (tags instanceof DOMObject) {
-                await (tags as DOMObject).watchAttribute(this.attributeName);
-            }
-        } else if (tag) {
-            await tag.watchAttribute(this.attributeName);
-        }
-    }
-}

package/src/AST/ElementQueryNode.ts

@@ -1,48 +0,0 @@
-import {Scope} from "../Scope";
-import {DOM} from "../DOM";
-import {Tag, TagState} from "../Tag";
-import {Token, TreeNode} from "../AST";
-import {Node} from "./Node";
-import {EQuerySelectDirection} from "../DOM/AbstractDOM";
-
-export class ElementQueryNode extends Node implements TreeNode {
-    protected requiresPrep: boolean = true;
-
-    constructor(
-        public readonly query: string,
-        public readonly first: boolean = false,
-        public readonly direction: EQuerySelectDirection = EQuerySelectDirection.ALL,
-    ) {
-        super();
-    }
-
-    async evaluate(scope: Scope, dom: DOM, tag?: Tag, forceList: boolean = false): Promise<any> {
-        if (scope.isGarbage || (tag && tag.state === TagState.Deconstructed))
-            return;
-        return await this._evaluate(scope, dom, tag, forceList);
-    }
-
-    protected async _evaluate(scope: Scope, dom: DOM, tag: Tag = null, forceList: boolean = false): Promise<any> {
-        tag = tag || await dom.getTagForScope(scope);
-        const elements = await dom.get(this.query, true, tag, this.direction);
-        return this.first && !forceList ? elements[0] : elements;
-    }
-
-    async prepare(scope: Scope, dom: DOM, tag: Tag = null, meta: any = null): Promise<any> {
-        tag = tag || await dom.getTagForScope(scope);
-        await dom.get(this.query, true, tag);
-    }
-
-    public static parse(lastNode, token, tokens: Token[]): ElementQueryNode {
-        tokens.shift();
-        let first = false;
-        let direction = EQuerySelectDirection.ALL;
-        if (token.full.startsWith('?>')) {
-            direction = EQuerySelectDirection.DOWN;
-        } else if (token.full.startsWith('?<')) {
-            direction = EQuerySelectDirection.UP;
-            first = true;
-        }
-        return new ElementQueryNode(token.value, first, direction);
-    }
-}

package/src/AST/ElementStyleNode.ts

@@ -1,74 +0,0 @@
-import {Scope} from "../Scope";
-import {DOM} from "../DOM";
-import {Tag} from "../Tag";
-import {TagList} from "../Tag/TagList";
-import {TreeNode} from "../AST";
-import {Node} from "./Node";
-import {ElementQueryNode} from "./ElementQueryNode";
-import {LiteralNode} from "./LiteralNode";
-import {DOMObject} from "../DOM/DOMObject";
-
-export class ElementStyleNode extends Node implements TreeNode {
-    protected requiresPrep: boolean = true;
-
-    constructor(
-        public readonly elementRef: ElementQueryNode | null,
-        public readonly attr: string
-    ) {
-        super();
-    }
-
-    public get name(): LiteralNode<string> {
-        return new LiteralNode<string>(`$${this.attributeName}`);
-    }
-
-    protected _getChildNodes(): Node[] {
-        let nodes = [];
-        if (this.elementRef)
-            nodes.push(this.elementRef)
-        return nodes;
-    }
-
-    get attributeName(): string {
-        if (this.attr.startsWith('.'))
-            return this.attr.substring(2);
-        return this.attr.substring(1);
-    }
-
-    protected async _evaluate(scope: Scope, dom: DOM, tag: Tag = null) {
-        let tags: TagList;
-        if (this.elementRef) {
-            tags = await this.elementRef.evaluate(scope, dom, tag, true);
-        } else if (tag) {
-            tags = new TagList(tag)
-        } else {
-            return;
-        }
-
-        if (tags instanceof DOMObject)
-            tags = new TagList(tags);
-
-        if (tags.length === 1) {
-            return this.getAttributeStyleValue(tags[0]);
-        }
-
-        return tags.map((tag) => this.getAttributeStyleValue(tag));
-    }
-
-    async getAttributeStyleValue(tag: Tag | DOMObject): Promise<string> {
-        // Make sure we're watching the style
-        await tag.watchStyle(this.attributeName);
-        return tag.scope.get(`$${this.attributeName}`);
-    }
-
-    async prepare(scope: Scope, dom: DOM, tag: Tag = null, meta: any = null) {
-        if (this.elementRef) {
-            await this.elementRef.prepare(scope, dom, tag, meta);
-            const tags: TagList = await this.elementRef.evaluate(scope, dom, tag, true);
-            for (const t of tags)
-                await t.watchStyle(this.attributeName);
-        } else if(tag) {
-            await tag.watchStyle(this.attributeName);
-        }
-    }
-}