vsn 0.1.43 → 0.1.46

package/src/DOM.ts

@@ -3,8 +3,6 @@ import {ElementHelper} from "./helpers/ElementHelper";
 import {Configuration} from "./Configuration";
 import {Tree} from "./AST";
 import {TagList} from "./Tag/List";
-import {benchmarkEnd, benchmarkStart} from "./Bencmark";
-import {VisionHelper} from "./helpers/VisionHelper";
 import {WrappedWindow} from "./DOM/WrappedWindow";
 import {WrappedDocument} from "./DOM/WrappedDocument";
 import {Scope} from "./Scope";
@@ -50,6 +48,8 @@ export class DOM extends EventDispatcher {
                 return new TagList(this.window);
             case 'document':
                 return new TagList(this.document);
+            case 'body':
+                return new TagList(this.root);
             default:
                 const nodes = this.querySelectorAll(selector, tag);
                 return await this.getTagsForElements(Array.from(nodes) as Element[], create);
@@ -119,6 +119,13 @@ export class DOM extends EventDispatcher {
             if (tag) {
                 tag.mutate(mutation);
             }
+
+            for (const ele of Array.from(mutation.removedNodes)) {
+                const toRemove: Tag = await this.getTagForElement(ele as HTMLElement);
+                if (toRemove) {
+                    toRemove.deconstruct();
+                }
+            }
         }
     }
 
@@ -139,7 +146,6 @@ export class DOM extends EventDispatcher {
         const toBuild: HTMLElement[] = [];
         const toSkip: HTMLElement[] = [];
 
-        if (VisionHelper.doBenchmark) benchmarkStart('DOM','findElements');
         if (ele && ele.querySelectorAll) {
             for (const element of (Array.from(ele.querySelectorAll(`*`)) as HTMLElement[])) { // Don't build items more than once
                 if (!ElementHelper.hasVisionAttribute(element)) continue;
@@ -152,9 +158,7 @@ export class DOM extends EventDispatcher {
                 toBuild.push(element);
             }
         }
-        if (VisionHelper.doBenchmark) benchmarkEnd('DOM', 'findElements');
 
-        if (VisionHelper.doBenchmark) benchmarkStart('DOM', 'buildTags');
         for (const element of toBuild) {
             if (allElements.indexOf(element) > -1) continue;
             const tag: Tag = new Tag(element, this);
@@ -162,23 +166,17 @@ export class DOM extends EventDispatcher {
             newTags.push(tag);
             allElements.push(element as HTMLElement);
         }
-        if (VisionHelper.doBenchmark) benchmarkEnd('DOM', 'buildTags');
 
         if (isRoot)
             this._root = await this.getTagForElement(document.body);
 
         // Configure, setup & execute attributes
-        if (VisionHelper.doBenchmark) benchmarkStart('DOM','buildTagAttributes');
         for (const tag of newTags)
             await tag.buildAttributes();
-        if (VisionHelper.doBenchmark) benchmarkEnd('DOM','buildTagAttributes');
 
-        if (VisionHelper.inDevelopment) benchmarkStart('DOM', 'compileAttributes');
         for (const tag of newTags)
             await tag.compileAttributes();
-        if (VisionHelper.doBenchmark) benchmarkEnd('DOM','compileAttributes');
 
-        if (VisionHelper.doBenchmark) benchmarkStart('DOM', 'buildTree');
         for (const tag of newTags) {
             if (tag === this.root)
                 continue;
@@ -198,39 +196,27 @@ export class DOM extends EventDispatcher {
             if (!foundParent)
                 console.error('Could not find parent for ', tag);
         }
-        if (VisionHelper.doBenchmark) benchmarkEnd('DOM', 'buildTree');
 
-        if (VisionHelper.doBenchmark) benchmarkStart('DOM', 'setupAttributes');
         for (const tag of newTags)
             await tag.setupAttributes();
-        if (VisionHelper.doBenchmark) benchmarkEnd('DOM', 'setupAttributes');
 
-        if (VisionHelper.doBenchmark) benchmarkStart('DOM', 'extractAttributes');
         for (const tag of newTags)
             await tag.extractAttributes();
-        if (VisionHelper.doBenchmark) benchmarkEnd('DOM', 'extractAttributes');
 
-        if (VisionHelper.doBenchmark) benchmarkStart('DOM', 'connectAttributes');
         for (const tag of newTags)
             await tag.connectAttributes();
-        if (VisionHelper.doBenchmark) benchmarkEnd('DOM', 'connectAttributes');
 
-        if (VisionHelper.doBenchmark) benchmarkStart('DOM', 'finalizeTags');
         for (const tag of newTags) {
             await tag.finalize();
             this.queued.splice(this.queued.indexOf(tag.element), 1);
         }
-        if (VisionHelper.doBenchmark) benchmarkEnd('DOM', 'finalizeTags');
 
-        if (VisionHelper.doBenchmark) benchmarkStart('DOM', 'observeTags');
-        for (const tag of newTags)
-            this.observer.observe(tag.element, {
+        newTags.forEach(tag => this.observer.observe(tag.element, {
                 attributes: true,
                 characterData: true,
                 childList: true,
                 subtree: true
-            });
-        if (VisionHelper.doBenchmark) benchmarkEnd('DOM', 'observeTags');
+            }));
 
         this.dispatch('built');
     }

package/src/Registry.ts

@@ -1,4 +1,3 @@
-import {VisionHelper} from "./helpers/VisionHelper";
 import {EventDispatcher} from "./EventDispatcher";
 import {IDeferred, IPromise, SimplePromise} from "./SimplePromise";
 
@@ -53,6 +52,7 @@ export class RegistryStore extends EventDispatcher {
 
 export class Registry extends EventDispatcher {
     protected static _instance: Registry;
+    public readonly components: RegistryStore;
     public readonly classes: RegistryStore;
     public readonly models: RegistryStore;
     public readonly templates: RegistryStore;
@@ -63,15 +63,18 @@ export class Registry extends EventDispatcher {
 
     constructor() {
         super();
+        this.components = new RegistryStore();
+        this.classes = new RegistryStore();
+        this.models = new RegistryStore();
+        this.templates = new RegistryStore();
+        this.types = new RegistryStore();
+        this.validators = new RegistryStore();
+        this.formats = new RegistryStore();
+        this.attributes = new RegistryStore();
+    }
 
-        const w = VisionHelper.window || {};
-        this.classes = new RegistryStore(w['$classes'] || {});
-        this.models = new RegistryStore(w['$models'] || {});
-        this.templates = new RegistryStore(w['$templates'] || {});
-        this.types = new RegistryStore(w['$types'] || {});
-        this.validators = new RegistryStore(w['$validators'] || {});
-        this.formats = new RegistryStore(w['$formats'] || {});
-        this.attributes = new RegistryStore(w['$attributes'] || {});
+    public static component(key: string = null, setup = null) {
+        return register('components', key, setup);
     }
 
     public static class(key: string = null, setup = null) {

package/src/Scope/ScopeDataAbstract.ts

@@ -65,7 +65,7 @@ export class ScopeDataAbstract extends EventDispatcher {
         const keys = [];
         for (const key of this.keys) {
             const property = this.getProperty(key);
-            if (property.hasTags(tags)) {
+            if (property.hasLabels(tags)) {
                 keys.push(key);
             }
         }
@@ -86,7 +86,7 @@ export class ScopeDataAbstract extends EventDispatcher {
         propLoop: for (const key of this.getProperties()) {
             const property = this['__'+key];
             for (const tag of tags) {
-                if (!property.hasTag(tag))
+                if (!property.hasLabel(tag))
                     continue propLoop;
             }
 

package/src/Scope/properties/Property.ts

@@ -30,7 +30,7 @@ export interface IPropertyConfig {
     type?: string;
     default?: any;
     validators?: TValidator[];
-    tags?: string[];
+    labels?: string[];
 }
 
 export class Property<T = any> extends EventDispatcher {
@@ -41,8 +41,8 @@ export class Property<T = any> extends EventDispatcher {
     constructor(value?: T, config?: IPropertyConfig) {
         super();
         this.config = config;
-        if (!this.config.tags)
-            this.config.tags = [];
+        if (!this.config.labels)
+            this.config.labels = [];
         if (!this.config.validators)
             this.config.validators = [];
         this.type = config.type || 'any';
@@ -109,43 +109,32 @@ export class Property<T = any> extends EventDispatcher {
             this.config.validators.push(validator);
     }
 
-    removeValidator(validator: TValidator | string) {
-        if (typeof validator == 'string') {
-            validator = this.getValidator(validator);
-        }
-
-        const index = this.config.validators.indexOf(validator);
-        if (index != -1)
-            this.config.validators.splice(index, 1);
-    }
-
-
-    addTag(tag: string) {
-        if(this.config.tags == undefined) {
-            this.config.tags = [];
+    addLabel(label: string) {
+        if(this.config.labels == undefined) {
+            this.config.labels = [];
         }
-        if(this.config.tags.indexOf(tag) == -1) {
-            this.config.tags.push(tag);
+        if(this.config.labels.indexOf(label) == -1) {
+            this.config.labels.push(label);
         }
     }
 
-    removeTag(tag: string) {
-        if(this.config.tags == undefined) {
+    removeLabel(label: string) {
+        if(this.config.labels == undefined) {
             return;
         }
-        const index = this.config.tags.indexOf(tag);
+        const index = this.config.labels.indexOf(label);
         if(index != -1) {
-            this.config.tags.splice(index, 1);
+            this.config.labels.splice(index, 1);
         }
     }
 
-    hasTag(tag: string) {
-        return this.config.tags.indexOf(tag) !== -1;
+    hasLabel(label: string) {
+        return this.config.labels.indexOf(label) !== -1;
     }
 
-    hasTags(tags: string[]) {
-        for(const tag of tags) {
-            if(!this.hasTag(tag)) {
+    hasLabels(labels: string[]) {
+        for(const label of labels) {
+            if(!this.hasLabel(label)) {
                 return false;
             }
         }

package/src/Scope/properties/_imports.ts

@@ -1,2 +1,2 @@
-export {Property, property} from './Property';
+export {Property, property, IPropertyConfig} from './Property';
 export {ArrayProperty} from './ArrayProperty';

package/src/Tag.ts

@@ -72,12 +72,7 @@ export class Tag extends DOMObject {
         if (this._nonDeferredAttributes.length > 0)
             return this._nonDeferredAttributes;
 
-        const attrs: Attribute[] = [];
-        for (const attribute of this.attributes) {
-            if (attribute.state === AttributeState.Deferred)
-                continue;
-            attrs.push(attribute);
-        }
+        const attrs: Attribute[] = this.attributes.filter(attr => attr.state !== AttributeState.Deferred);
         this._nonDeferredAttributes = attrs;
         return attrs;
     }
@@ -119,9 +114,7 @@ export class Tag extends DOMObject {
     }
 
     mutate(mutation: MutationRecord): void {
-        for (const attr of this.attributes) {
-            attr.mutate(mutation);
-        }
+        this.attributes.map(attr => attr.mutate(mutation));
         this.dispatch('mutate', mutation);
     }
 
@@ -579,4 +572,12 @@ export class Tag extends DOMObject {
             await this.setupAttribute(attr);
         this.deferredAttributes.length = 0;
     }
+
+    deconstruct() {
+        this.attributes.forEach(attr => attr.deconstruct());
+        this.attributes.length = 0;
+        this._children.forEach(child => child.deconstruct());
+        this._children.length = 0;
+        super.deconstruct();
+    }
 }

package/src/attributes/AddClassIf.ts

@@ -11,4 +11,4 @@ export class AddClassIf extends If {
             this.tag.element.classList.remove(this.getAttributeBinding());
         }
     }
-}
+}

package/src/attributes/StandardAttribute.ts

@@ -1,4 +1,5 @@
 import {Attribute} from "../Attribute";
+import {DOM} from "../DOM";
 
 export class StandardAttribute extends Attribute {
     public static readonly canDefer: boolean = false;
@@ -66,9 +67,10 @@ export class StandardAttribute extends Attribute {
     public set value(value: any) {
         if (this.key === '@text')
             this.tag.element.innerText = value;
-        else if (this.key === '@html')
+        else if (this.key === '@html') {
             this.tag.element.innerHTML = value;
-        else if (this.key === '@value')
+            DOM.instance.buildFrom(this.tag.element);
+        } else if (this.key === '@value')
             this.tag.value = value;
         else if (this.key === '@class' && value) {
             this.tag.element.classList.remove(...Array.from(this.tag.element.classList));

package/src/attributes/_imports.ts

@@ -1,7 +1,5 @@
 export {AddClassIf} from "./AddClassIf";
 export {Bind} from "./Bind";
-export {ClickRemoveClass} from "./ClickRemoveClass";
-export {ClickToggleClass} from "./ClickToggleClass";
 export {ControllerAttribute} from "./ControllerAttribute";
 export {DisableIf} from "./DisableIf";
 export {Exec} from "./Exec";

package/src/helpers/VisionHelper.ts

@@ -47,4 +47,17 @@ export class VisionHelper {
             setTimeout(callback, timeout);
         }
     }
+
+    public static get wasmSupport(): boolean {
+        try {
+            if (typeof WebAssembly === "object"
+                && typeof WebAssembly.instantiate === "function") {
+                const module = new WebAssembly.Module(Uint8Array.of(0x0, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00));
+                if (module instanceof WebAssembly.Module)
+                    return new WebAssembly.Instance(module) instanceof WebAssembly.Instance;
+            }
+        } catch (e) {
+        }
+        return false;
+    }
 }

package/src/vsn.ts

@@ -1,8 +1,6 @@
 import {DOM} from "./DOM";
 import {WrappedArray} from "./Scope/WrappedArray";
 import {Registry} from "./Registry";
-import "./Types";
-import "./Formats";
 import {Configuration} from "./Configuration";
 import {VisionHelper} from "./helpers/VisionHelper";
 import {Tree} from "./AST";
@@ -83,4 +81,7 @@ export {EventDispatcher} from './EventDispatcher';
 export {MessageList} from './MessageList';
 export {SimplePromise} from './SimplePromise';
 export {Tag} from './Tag';
+export {Formats} from './Formats';
+export {Types} from './Types';
+export {Validators} from './Validators';
 export const vision: Vision = Vision.instance;

package/test/AST/ArithmeticAssignmentNode.spec.ts

@@ -1,5 +1,3 @@
-import {SimplePromise} from "../../src/SimplePromise";
-import {DOM} from "../../src/DOM";
 import {Tree} from "../../src/AST";
 import {Scope} from "../../src/Scope";
 

package/test/AST/StringFormatNode.spec.ts

@@ -0,0 +1,12 @@
+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

@@ -0,0 +1,63 @@
+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

@@ -0,0 +1,10 @@
+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();
+    });
+});

package/test/Scope/ScopeData.spec.ts

@@ -6,15 +6,15 @@ describe('ScopeData', () => {
     it("should set tags correctly", async () => {
         const data = new ScopeData();
         data.createProperty('test', Property, {
-            tags: ['test']
+            labels: ['test']
         });
 
         data.createProperty('test_int', Property, {
-            tags: ['test']
+            labels: ['test']
         });
 
         data.createProperty('not_test', Property, {
-            tags: ['not_test']
+            labels: ['not_test']
         });
 
         data['test'] = 'test';
@@ -40,7 +40,7 @@ describe('ScopeData', () => {
         });
 
         const notTestProp = data.getProperty('not_test');
-        notTestProp.addTag('test');
+        notTestProp.addLabel('test');
         const taggedNotTestData2 = data.getData('test');
         expect(taggedNotTestData2).toEqual({
             test: 'test',
@@ -48,7 +48,7 @@ describe('ScopeData', () => {
             not_test: 'not_test'
         });
 
-        notTestProp.removeTag('test');
+        notTestProp.removeLabel('test');
         const taggedNotTestData3 = data.getData('test');
         expect(taggedNotTestData3).toEqual({
             test: 'test',

package/types/vsn-component.d.ts

@@ -0,0 +1,5 @@
+
+declare module "*.vsn" {
+  const content: string;
+  export default content;
+}

package/dist/attributes/ClickRemoveClass.d.ts

@@ -1,8 +0,0 @@
-import { Attribute } from "../Attribute";
-export declare class ClickRemoveClass extends Attribute {
-    protected cssClass: string;
-    protected target: string;
-    setup(): Promise<void>;
-    connect(): Promise<void>;
-    onClick(e: any): void;
-}

package/dist/attributes/ClickRemoveClass.js

@@ -1,114 +0,0 @@
-"use strict";
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ClickRemoveClass = void 0;
-var Attribute_1 = require("../Attribute");
-var Registry_1 = require("../Registry");
-var ClickRemoveClass = /** @class */ (function (_super) {
-    __extends(ClickRemoveClass, _super);
-    function ClickRemoveClass() {
-        var _this = _super !== null && _super.apply(this, arguments) || this;
-        _this.cssClass = '';
-        _this.target = null;
-        return _this;
-    }
-    ClickRemoveClass.prototype.setup = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        this.cssClass = this.getAttributeBinding('active');
-                        this.target = this.getAttributeValue();
-                        return [4 /*yield*/, _super.prototype.setup.call(this)];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/];
-                }
-            });
-        });
-    };
-    ClickRemoveClass.prototype.connect = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        this.tag.addEventHandler('click', this.getAttributeModifiers(), this.onClick.bind(this));
-                        return [4 /*yield*/, _super.prototype.connect.call(this)];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/];
-                }
-            });
-        });
-    };
-    ClickRemoveClass.prototype.onClick = function (e) {
-        var element = this.tag.element;
-        if (!!this.target) {
-            element = document.getElementById(this.target);
-        }
-        if (element)
-            element.classList.remove(this.cssClass);
-    };
-    ClickRemoveClass = __decorate([
-        Registry_1.Registry.attribute('vsn-click-remove-class')
-    ], ClickRemoveClass);
-    return ClickRemoveClass;
-}(Attribute_1.Attribute));
-exports.ClickRemoveClass = ClickRemoveClass;
-//# sourceMappingURL=ClickRemoveClass.js.map

package/dist/attributes/ClickRemoveClass.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ClickRemoveClass.js","sourceRoot":"","sources":["../../src/attributes/ClickRemoveClass.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,0CAAuC;AACvC,wCAAqC;AAGrC;IAAsC,oCAAS;IAA/C;QAAA,qEAyBC;QAxBa,cAAQ,GAAW,EAAE,CAAC;QACtB,YAAM,GAAW,IAAI,CAAC;;IAuBpC,CAAC;IArBgB,gCAAK,GAAlB;;;;;wBACI,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,mBAAmB,CAAC,QAAQ,CAAC,CAAC;wBACnD,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,iBAAiB,EAAE,CAAC;wBACvC,qBAAM,iBAAM,KAAK,WAAE,EAAA;;wBAAnB,SAAmB,CAAC;;;;;KACvB;IAEY,kCAAO,GAApB;;;;;wBACI,IAAI,CAAC,GAAG,CAAC,eAAe,CAAC,OAAO,EAAE,IAAI,CAAC,qBAAqB,EAAE,EAAE,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;wBACzF,qBAAM,iBAAM,OAAO,WAAE,EAAA;;wBAArB,SAAqB,CAAC;;;;;KACzB;IAED,kCAAO,GAAP,UAAQ,CAAC;QACL,IAAI,OAAO,GAAG,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC;QAE/B,IAAI,CAAC,CAAC,IAAI,CAAC,MAAM,EAAE;YACf,OAAO,GAAG,QAAQ,CAAC,cAAc,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;SAClD;QAED,IAAI,OAAO;YACP,OAAO,CAAC,SAAS,CAAC,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;IAChD,CAAC;IAxBQ,gBAAgB;QAD5B,mBAAQ,CAAC,SAAS,CAAC,wBAAwB,CAAC;OAChC,gBAAgB,CAyB5B;IAAD,uBAAC;CAAA,AAzBD,CAAsC,qBAAS,GAyB9C;AAzBY,4CAAgB"}

package/dist/attributes/ClickToggleClass.d.ts

@@ -1,8 +0,0 @@
-import { Attribute } from "../Attribute";
-export declare class ClickToggleClass extends Attribute {
-    protected cssClass: string;
-    protected target: string;
-    setup(): Promise<void>;
-    connect(): Promise<void>;
-    onClick(e: any): void;
-}

package/dist/attributes/ClickToggleClass.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ClickToggleClass.js","sourceRoot":"","sources":["../../src/attributes/ClickToggleClass.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,0CAAuC;AACvC,wCAAqC;AAGrC;IAAsC,oCAAS;IAA/C;QAAA,qEAyBC;QAxBa,cAAQ,GAAW,EAAE,CAAC;QACtB,YAAM,GAAW,IAAI,CAAC;;IAuBpC,CAAC;IArBgB,gCAAK,GAAlB;;;;;wBACI,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,mBAAmB,CAAE,QAAQ,CAAC,CAAC;wBACpD,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,iBAAiB,EAAE,CAAC;wBACvC,qBAAM,iBAAM,KAAK,WAAE,EAAA;;wBAAnB,SAAmB,CAAC;;;;;KACvB;IAEY,kCAAO,GAApB;;;;;wBACI,IAAI,CAAC,GAAG,CAAC,eAAe,CAAC,OAAO,EAAE,IAAI,CAAC,qBAAqB,EAAE,EAAE,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;wBACzF,qBAAM,iBAAM,OAAO,WAAE,EAAA;;wBAArB,SAAqB,CAAC;;;;;KACzB;IAED,kCAAO,GAAP,UAAQ,CAAC;QACL,IAAI,OAAO,GAAG,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC;QAC/B,IAAI,CAAC,CAAC,IAAI,CAAC,MAAM,EAAE;YAEf,OAAO,GAAG,QAAQ,CAAC,cAAc,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;SAClD;QAED,IAAI,OAAO;YACP,OAAO,CAAC,SAAS,CAAC,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;IAChD,CAAC;IAxBQ,gBAAgB;QAD5B,mBAAQ,CAAC,SAAS,CAAC,wBAAwB,CAAC;OAChC,gBAAgB,CAyB5B;IAAD,uBAAC;CAAA,AAzBD,CAAsC,qBAAS,GAyB9C;AAzBY,4CAAgB"}