vsn 0.1.149 → 1.0.1

package/src/vsn.ts

@@ -1,106 +0,0 @@
-import {DOM} from "./DOM";
-import {WrappedArray} from "./Scope/WrappedArray";
-import {Registry} from "./Registry";
-import {Configuration} from "./Configuration";
-import {VisionHelper} from "./helpers/VisionHelper";
-import {Tree} from "./AST";
-import {EventDispatcher} from "./EventDispatcher";
-import {DynamicScopeData} from "./Scope/DynamicScopeData";
-import {Scope} from "./Scope";
-import {VERSION} from "./version";
-import './custom-elements';
-
-export class Vision extends EventDispatcher {
-    protected static _instance: Vision;
-    protected _dom?: DOM;
-    public readonly registry = Registry.instance;
-    public readonly config: Configuration = Configuration.instance;
-
-    constructor() {
-        super();
-        document.ondragover = (e) => e.cancelable && e.preventDefault();  // Allow dragging over document
-        Registry.instance.tags.on('register', this.defineComponent, this);
-        if (VisionHelper.document) {
-            document.addEventListener(
-                "DOMContentLoaded",
-                this.setup.bind(this)
-            );
-        } else {
-            console.warn('No dom, running in CLI mode.');
-        }
-        this.registry.functions.register('log', console.log);
-        this.registry.functions.register('warn', console.warn);
-        this.registry.functions.register('error', console.error);
-        this.registry.functions.register('info', console.info);
-        this.registry.functions.register('wait', VisionHelper.wait);
-        this.registry.models.register('Object', Object);
-        this.registry.controllers.register('WrappedArray', WrappedArray);
-        this.registry.controllers.register('Data', DynamicScopeData);
-
-        if (VisionHelper.window) {
-            window['Vision'] = Vision;
-            window['Registry'] = Registry;
-            window['vision'] = window['vsn'] = this;
-            window['Tree'] = Tree;
-            window['Scope'] = Scope;
-            window['$'] = this.exec.bind(this);
-            VisionHelper.window.dispatchEvent(new Event('vsn'));
-        }
-    }
-
-    protected defineComponent(name, cls) {
-        if (DOM.instance.built) {
-            customElements.define(name, cls);
-        } else {
-            DOM.instance.once('built', () => {
-                customElements.define(name, cls);
-            });
-        }
-    }
-
-    public get dom(): DOM {
-        return this._dom;
-    }
-
-    public async exec(code: string, data?: any) {
-        return await this._dom.exec(code, data);
-    }
-
-    public async setup() {
-        const body: HTMLElement = document.body;
-        body.setAttribute('vsn-root', '');
-        this._dom = DOM.instance;
-        const startTime: number = new Date().getTime();
-        await this._dom.buildFrom(document, true);
-        const now = (new Date()).getTime();
-        const setupTime = now - startTime;
-        console.info(`Took ${setupTime}ms to start up VisionJS. https://www.vsnjs.com/`, `v${VERSION}`);
-    }
-
-    public static get instance() {
-        if (!Vision._instance)
-            Vision._instance = new Vision();
-
-        return Vision._instance;
-    }
-}
-
-export * from './Registry';
-export * from "./attributes/_imports";
-export * from './Scope/properties/_imports';
-export * from './Attribute';
-export * from './AST';
-export {Formats} from './Formats';
-export {Types} from './Types';
-export {Validators} from './Validators';
-export {DOM} from './DOM';
-export {Scope} from './Scope';
-export {ScopeReference} from './Scope/ScopeReference';
-export {WrappedArray} from './Scope/WrappedArray';
-export {Controller} from './Controller';
-export {Model} from './Model';
-export {Service} from './Service';
-export {EventDispatcher} from './EventDispatcher';
-export {MessageList} from './MessageList';
-export {Tag} from './Tag';
-export const vision: Vision = Vision.instance;

package/test/AST/ArithmeticAssignmentNode.spec.ts

@@ -1,45 +0,0 @@
-import {Tree} from "../../src/AST";
-import {Scope} from "../../src/Scope";
-
-
-describe('ArithmeticAssignmentNode', () => {
-    it("should support simple arithmetic with numbers", async () => {
-        const tree = new Tree(`
-            a = 1;
-            a += 10;
-            b = a + 1;
-            b -= 10;
-            c = a + 1;
-            c /= 2;
-            d = a + 1;
-            d *= 2;
-        `);
-        const scope = new Scope();
-        await tree.evaluate(scope, null, null);
-        expect(scope.get("a")).toBe(11);
-        expect(scope.get("b")).toBe(2);
-        expect(scope.get("c")).toBe(6);
-        expect(scope.get("d")).toBe(24);
-    });
-
-    it("should support simple arithmetic with numbers inside nested objects", async () => {
-        const tree = new Tree(`
-            z = {};
-            a = 100;
-            z.z = {};
-            z.z.a = 10;
-            z.a = 1;
-            z.b = 15;
-            z.a += z.z.a;
-            z.b *= a + z.a + z.b;
-            z.z.b = z.z.a + z.a;
-            z.z.b *= z.z.a;
-        `);
-        const scope = new Scope();
-        await tree.evaluate(scope, null, null);
-        expect(await Tree.apply('z.z.a', scope, null, null)).toBe(10);
-        expect(await Tree.apply('z.a', scope, null, null)).toBe(11);
-        expect(await Tree.apply('z.b', scope, null, null)).toBe(1890);
-        expect(await Tree.apply('z.z.b', scope, null, null)).toBe(210);
-    });
-});

package/test/AST/ClassNode.spec.ts

@@ -1,175 +0,0 @@
-import {DOM} from "../../src/DOM";
-import {ClassNode} from "../../src/AST/ClassNode";
-import {Registry} from "../../src/Registry";
-import {TagList} from "../../src/Tag/TagList";
-import {Tag} from "../../src/vsn";
-
-
-describe('ClassNode', () => {
-    it("properly combine nested classes", async () => {
-        document.body.innerHTML = `
-            <script type="text/vsn" vsn-script>
-            class .simple { 
-                func construct() {}
-                class input {
-                    func construct() {}
-                }
-            }
-            </script>
-            <div class="simple"><input /></div>
-            <input id="not-nested" />
-        `;
-        const dom = new DOM(document.body);
-        await dom.ready;
-        await Registry.instance.classes.get('.simple input');
-        expect(ClassNode.classParents['input']).toBeInstanceOf(Array);
-        expect(ClassNode.classParents['input'].includes('.simple input')).toBe(true);
-        expect(ClassNode.classes['.simple input']).toBeInstanceOf(ClassNode);
-    });
-
-    it("properly build classes on newly added elements in the dom", async () => {
-        document.body.innerHTML = `
-            <script type="text/vsn" vsn-script>
-            class .added-html { 
-                func construct() {}
-            }
-            </script>
-            <div id="container"></div>
-        `;
-        const dom = new DOM(document.body);
-        await dom.ready;
-        await Registry.instance.classes.get('.added-html');
-        const newHtml: string = `<div class="added-html" id="added"></div>`;
-        dom.root.scope.set('newHtml', newHtml);
-        await dom.exec('#container.@html = newHtml');
-        const addedTag = await dom.exec('#added');
-        expect(addedTag).toBeInstanceOf(Tag);
-        expect(ClassNode.preppedTags['.added-html'].indexOf(addedTag)).toBeGreaterThan(-1);
-    });
-
-    it("properly define a simple class", async () => {
-        document.body.innerHTML = `
-            <script type="text/vsn" vsn-script>
-            class .simple-construct { 
-                func construct() {
-                    this.a|integer = "15";
-                    log('####### construct', this.a);
-                }
-                
-                func test() {
-                    this.a += 1;
-                    log('####### testing', this.a);
-                }
-            }
-            </script>
-            <div class="simple-construct" id="ele-1"></div>
-            <div class="simple-construct" id="ele-2"></div>
-        `;
-        const dom = new DOM(document.body);
-        await dom.ready;
-        await Registry.instance.classes.get('.simple-construct');
-        const t: TagList = await dom.exec('?(.simple-construct)');
-        expect(t).toBeInstanceOf(TagList);
-        expect(t.length).toBe(2);
-        await t.all('.simple-construct.construct');
-        expect(await dom.exec('?(.simple-construct).a')).toEqual([15, 15]);
-        await dom.exec('?(.simple-construct).test()');
-        expect(await dom.exec('?(.simple-construct).a')).toEqual([16, 16]);
-    });
-
-    it("properly define a simple class with a parent", async () => {
-        document.body.innerHTML = `
-            <script type="text/vsn" vsn-script>
-            class .testing { 
-                func construct() {
-                    this.a|integer = 0;
-                }
-                
-                class .test {
-                    func construct() {
-                        ?<(.testing).a += 1;
-                    }
-                }
-            }
-            </script>
-            <div class="testing"><span class="test"></span></div>
-        `;
-        const dom = new DOM(document.body);
-        await dom.ready;
-        await Registry.instance.classes.get('.testing .test');
-        const t = await dom.exec('?(.testing .test)[0]');
-        await t.promise('.testing .test.construct');
-        expect(await dom.exec('?(.testing)[0].a')).toEqual(1);
-    });
-
-    it("properly define a simple class with a parent", async () => {
-        document.body.innerHTML = `
-<script type="text/vsn" vsn-script>
-class .option {
-    func construct() {
-        log('construct');
-    }
-        
-    func open() {
-        log(@data-type, 'open');
-    }
-
-    func close() {
-        log(@data-type, 'close');
-    }
-
-    func filter(value) {
-        log(@data-type, 'filter', value);
-    }
-
-    class input {
-        func construct() {
-            log('construct');
-        }
-        on focus() {
-            ?>(:parent).open();
-        }
-        
-        on blur() {
-            ?>(:parent).close();
-        }
-        
-        on keyup() {
-            ?>(:parent).filter(@value)
-        }
-    }
-
-    class .option-list {
-        func construct() {
-            log(?>(:parent input).@data-type, 'construct');
-        }
-    
-        class li {
-            func construct() {
-                log(@text);
-            }
-        }
-    }
-}
-</script>
-<div class="option">
-    <input data-type="normal" />
-    <ul class="option-list">
-        <li data-type="test">Foo</li>
-        <li data-type="test">Bar</li>
-        <li data-type="test">Baz</li>
-    </ul>
-</div>
-<div class="option">
-    <input data-type="reverse" />
-    <ul class="option-list">
-        <li data-type="tset">Oof</li>
-        <li data-type="tset">Rab</li>
-        <li data-type="tset">Zab</li>
-    </ul>
-</div>
-`;
-        const dom = new DOM(document.body);
-        await dom.ready;
-    });
-});

package/test/AST/FunctionNode.spec.ts

@@ -1,51 +0,0 @@
-import {Tree} from "../../src/AST";
-import {Scope} from "../../src/Scope";
-import {Registry} from "../../src/Registry";
-import {DOM, Service, Tag} from "../../src/vsn";
-
-
-@Registry.service('FunctionNodeScopeTestService')
-class FunctionNodeScopeTestController extends Service {
-    test1() {
-        return this.test2();
-    }
-
-    test2() {
-        return 99;
-    }
-}
-
-
-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);
-    });
-
-    it("should take a multitude of arguments", async () => {
-        const tree = new Tree(`func add(a_int, a_dict, a_arr) { log(a_int, a_dict['a'], a_arr[0]); return a_int + a_dict['a'] + a_arr[0]; }; add(1, {'a':1, 'b': 2}, [1]);`);
-        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);
-    });
-
-    it("methods should be callable with correct binding", async () => {
-        document.body.innerHTML = `
-            <div id="service-test" vsn-service:test="FunctionNodeScopeTestService"></div>
-        `;
-        const dom = new DOM(document.body);
-        await new Promise((resolve, reject) => {
-            dom.once('built', async () => {
-                const result = await dom.exec('test.test1()');
-                expect(result).toBe(99);
-                resolve(null);
-            });
-        });
-    });
-});

package/test/AST/StringFormatNode.spec.ts

@@ -1,12 +0,0 @@
-import {Tree} from "../../src/AST";
-import {Scope} from "../../src/Scope";
-
-
-describe('StringFormatNode', () => {
-    it("should format simple format strings", async () => {
-        const tree = new Tree("`Hello ${name}`");
-        const scope = new Scope();
-        scope.set("name", "World");
-        expect(await tree.evaluate(scope, null, null)).toBe("Hello World");
-    });
-});

package/test/AST/WASM.spec.ts

@@ -1,63 +0,0 @@
-import {compile, EOpCode, EValueType, run} from "../../src/AST/WASM";
-import {VisionHelper} from "../../src/helpers/VisionHelper";
-import {FunctionSection} from "../../src/AST/WASM/Function";
-
-describe('WASM', () => {
-    it("should support wasm", async () => {
-        expect(VisionHelper.wasmSupport).toBe(true);
-    });
-
-    it("should allow a simple addition function to be made", async () => {
-        const main = new FunctionSection("main");
-        main.addParam(EValueType.i32);
-        main.addParam(EValueType.i32);
-        main.addResult(EValueType.i32);
-        main.addCode([
-            0x00, // local declare count
-            EOpCode.get_local,
-            0x00, // local var 0
-            EOpCode.get_local,
-            0x01, // local var 1
-            EOpCode.i32_add,
-            EOpCode.end
-        ]);
-        expect(await run(main, 10, 15)).toBe(25);
-    });
-
-    it("should allow a simple subtraction function to be made", async () => {
-        const main = new FunctionSection("main");
-        main.addParam(EValueType.i32);
-        main.addParam(EValueType.i32);
-        main.addResult(EValueType.i32);
-        main.addCode([
-            0x00, // local declare count
-            EOpCode.get_local,
-            0x00, // local var 0
-            EOpCode.get_local,
-            0x01, // local var 1
-            EOpCode.i32_sub,
-            EOpCode.end
-        ]);
-        expect(await run(main, 10, 15)).toBe(-5);
-    });
-
-    it("should allow a simple function to be made", async () => {
-        const main = new FunctionSection("main");
-        main.addParam(EValueType.i32);
-        main.addParam(EValueType.i32);
-        main.addResult(EValueType.i32);
-        main.addCode([
-            0x00, // local declare count
-            EOpCode.get_local,
-            0x00, // local var 0
-            EOpCode.get_local,
-            0x01, // local var 1
-            EOpCode.i32_sub,
-            EOpCode.get_local,
-            0x00, // local var 0
-            EOpCode.i32_mul,
-            EOpCode.end
-        ]);
-        expect(await run(main, 100, 15)).toBe(8500);
-    });
-});

package/test/AST/XHRNode.spec.ts

@@ -1,10 +0,0 @@
-import {Tree} from "../../src/AST";
-import {Scope} from "../../src/Scope";
-
-
-describe('XHRNode', () => {
-    it("should parse and stuff", async () => {
-        const tree = new Tree(`{asd:123} >> '/test'`);
-        const scope = new Scope();
-    });
-});