vsn 0.1.149 → 1.0.1

package/src/Attribute.ts

@@ -1,130 +0,0 @@
-import {Tag} from "./Tag";
-import {EventDispatcher} from "./EventDispatcher";
-import {Modifiers} from "./Modifiers";
-
-export enum AttributeState {
-    Instantiated,
-    Deferred,
-    Compiled,
-    Setup,
-    Extracted,
-    Connected,
-    Built,
-    Disconnected
-}
-
-export abstract class Attribute extends EventDispatcher {
-    protected _state: AttributeState;
-    public readonly modifiers: Modifiers;
-    public static readonly scoped: boolean = false;
-    public static readonly canDefer: boolean = true;
-
-    constructor(
-        public readonly tag: Tag,
-        public readonly attributeName: string,
-        public readonly slot?: Tag
-    ) {
-        super();
-        this.modifiers = Modifiers.fromAttribute(attributeName)
-        this.configure();
-    }
-
-    public get origin(): Tag {
-        return this.slot || this.tag;
-    }
-
-    public get state(): AttributeState {
-        return this._state;
-    }
-
-    protected async defer() {
-        this.setState(AttributeState.Deferred);
-    }
-
-    protected async configure() {
-        this.setState(AttributeState.Instantiated);
-    }
-
-    public async compile() {
-        this.setState(AttributeState.Compiled);
-    }
-
-    public async setup() {
-        this.setState(AttributeState.Setup);
-    }
-
-    public async extract() {
-        this.setState(AttributeState.Extracted);
-    }
-
-    public async connect() {
-        this.setState(AttributeState.Connected);
-    }
-
-    public async finalize() {
-        this.setState(AttributeState.Built);
-    }
-
-    public async disconnect() {
-        this.setState(AttributeState.Disconnected);
-    }
-
-    public async evaluate() {}
-
-    public getAttributeValue(fallback: any = null) {
-        return this.origin.getRawAttributeValue(this.attributeName, fallback);
-    }
-
-    public getAttributeBinding(fallback: any = null): string {
-        return this.origin.getAttributeBinding(this.attributeName) || fallback;
-    }
-
-    public getAttributeModifiers(fallback: any = []): string[] {
-        return this.modifiers.length && this.modifiers.names || fallback;
-    }
-
-    public getAttributeModifierArguments(modifier: string, fallback: string[] = []): string[] {
-        return this.modifiers.has(modifier) ? this.modifiers.get(modifier).arguments : fallback;
-    }
-
-    public hasModifier(mod: string): boolean {
-        return this.modifiers.has(mod);
-    }
-
-    public mutate(mutation: MutationRecord): void {}
-
-    public set value(value: string) {
-        this.origin.element.setAttribute(this.attributeName, value);
-    }
-
-    public get value(): string {
-        return this.origin.element.getAttribute(this.attributeName) || '';
-    }
-
-    public async apply(fnc: Function) {
-        for (const element of this.origin.delegates) {
-            await fnc(element);
-        }
-    }
-
-    protected setState(state: AttributeState) {
-        const previousState = this._state;
-        this._state = state;
-        this.dispatch('state', {
-            state: state,
-            previousState: previousState,
-            attribute: this
-        });
-    }
-
-    public deconstruct() {
-        this.disconnect();
-        super.deconstruct();
-        (this as any).tag = null;
-        (this as any).slot = null;
-    }
-
-    public static create(tag: Tag, attributeName: string, cls: any, slot?: Tag): Attribute {
-        return new cls(tag, attributeName, slot);
-    }
-}

package/src/Bencmark.ts

@@ -1,184 +0,0 @@
-import {VisionHelper} from "./helpers/VisionHelper";
-
-export interface IBenchmark {
-    name: string;
-    tags: string[];
-    path: string;
-    time: number;
-}
-
-export type TTag = string[] | string;
-export const BENCHMARKS: IBenchmark[] = [];
-const BENCHMARK_STARTS: { [key: string]: Date } = {};
-
-function totags(tags: TTag): string[] {
-    tags = tags instanceof Array ? tags : tags && [tags] || [];
-    return tags.map((tag) => tag.toLowerCase());
-}
-
-function topath(name, tags) {
-    tags = [...totags(tags)];
-    tags.sort();
-    return tags.length && `${name}.${tags.join('.')}`.toLowerCase() || name && name.toLowerCase() || 'nopath';
-}
-
-function todata(name, tags: TTag, timeOrStart, end = null): IBenchmark {
-    if (end instanceof Date || Number.isFinite(end)) {
-        if (!Number.isFinite(timeOrStart) && timeOrStart instanceof Date)
-            timeOrStart = timeOrStart.getTime();
-
-        if (!Number.isFinite(end) && end instanceof Date)
-            end = end.getTime();
-
-        timeOrStart = end - timeOrStart;
-    }
-    tags = totags(tags);
-
-    return {
-        name: name,
-        tags: tags,
-        path: topath(name, tags),
-        time: timeOrStart
-    }
-}
-
-function hasTags(fullList: TTag, toMatch: TTag): boolean {
-    fullList = totags(fullList);
-    toMatch = totags(toMatch);
-    for (const tag in toMatch) {
-        if (fullList.indexOf(tag) === -1)
-            return false;
-    }
-
-    return true;
-}
-
-export function benchmark(name?: string, tags?: TTag, print: boolean = false) {
-    return function (target: any, key?: string, descriptor?: PropertyDescriptor): void {
-        if (VisionHelper.doBenchmark) {
-            const method: (...args: any[]) => any = descriptor.value;
-
-            descriptor.value = function (...args): any {
-                name = target.__BENCHMARK_NAME__ || name || key;
-                tags = totags(tags);
-                if (target.__BENCHMARK_NAME__ || target.__BENCHMARK_TAGS__) {
-                    tags.push(name || key);
-                    tags.push(...target.__BENCHMARK_TAGS__);
-                }
-                const start: Date = new Date();
-                const result = method.apply(this, args);
-                const end: Date = new Date();
-                const data = todata(name, tags, start, end);
-                BENCHMARKS.push(data);
-
-                if (print)
-                    console.log(data);
-
-                return result;
-            };
-        }
-    };
-}
-
-export function benchmarkStart(name: string, tags?: TTag) {
-    if (VisionHelper.doBenchmark) {
-        name = topath(name, tags);
-        BENCHMARK_STARTS[name] = new Date();
-    }
-}
-
-export function benchmarkEnd(name: string, tags?: TTag, print: boolean = null) {
-    if (VisionHelper.doBenchmark) {
-        const path = topath(name, tags);
-        const start: Date = BENCHMARK_STARTS[path];
-        const end: Date = new Date();
-        const data = todata(name, tags, start, end);
-        BENCHMARKS.push(data);
-        if (print || (print === null && data.time > 10)) {
-            const debugName = data.path ? `${name}[${data.path}]` : name;
-            console.warn(`${debugName} took ${data.time}ms to complete.`);
-        }
-        // Benchmark chaining
-        benchmarkStart(name);
-        return data;
-    }
-}
-
-export function benchmarkResults(name: string | null, tags: TTag = null): any {
-    if (VisionHelper.doBenchmark) {
-        const path = topath(name, tags);
-        let calls: number = 0;
-        let time: number = 0;
-        for (const bm of BENCHMARKS)
-            if ((!tags && bm.name === name) || bm.path === path || !name && hasTags(bm.tags, tags)) {
-                calls++;
-                time += bm.time;
-            }
-
-        return {
-            name: name,
-            calls: calls,
-            time: time,
-            average: time / calls
-        };
-    }
-}
-
-export function benchmarkResultsMatch(regexp: RegExp): any {
-    if (VisionHelper.doBenchmark) {
-        const data: any = {};
-        let calls: number = 0;
-        let time: number = 0;
-        for (const bm of BENCHMARKS) {
-            if (regexp.test(bm.name) && !data[bm.name]) {
-                data[bm.name] = benchmarkResults(bm.name);
-                calls += data[bm.name].calls;
-                time += data[bm.name].time;
-            }
-        }
-
-        data['ALL'] = {
-            name: 'ALL',
-            calls: calls,
-            time: time,
-            average: time / calls
-        };
-
-        return data;
-    }
-}
-
-export function benchmarkResultsAll(): any {
-    if (VisionHelper.doBenchmark) {
-        const data: any = {};
-        let calls: number = 0;
-        let time: number = 0;
-        for (const bm of BENCHMARKS) {
-            if (!data[bm.name]) {
-                const name = bm.path ? `${bm.name}.${bm.path}` : bm.name;
-                data[name] = benchmarkResults(bm.name, bm.tags);
-                calls += data[name].calls;
-                time += data[name].time;
-            }
-        }
-
-        data['ALL'] = {
-            name: 'ALL',
-            calls: calls,
-            time: time,
-            average: time / calls
-        };
-
-        return data;
-    }
-}
-
-if (VisionHelper.doBenchmark && VisionHelper.window) {
-    window['benchmark'] = benchmark;
-    window['benchmarks'] = BENCHMARKS;
-    window['benchmarkStart'] = benchmarkStart;
-    window['benchmarkEnd'] = benchmarkEnd;
-    window['benchmarkResults'] = benchmarkResults;
-    window['benchmarkResultsMatch'] = benchmarkResultsMatch;
-    window['benchmarkResultsAll'] = benchmarkResultsAll;
-}

package/src/Component.ts

@@ -1,63 +0,0 @@
-import {Registry} from "./Registry";
-import {SlotTag} from "./Tag/SlotTag";
-import {SlottedTag} from "./Tag/SlottedTag";
-import {ShadowDOM} from "./DOM/ShadowDOM";
-import {DOM} from "./DOM";
-
-export class Component extends HTMLElement {
-    protected readonly shadow: ShadowRoot;
-    protected readonly shadowDOM: ShadowDOM;
-
-    constructor() {
-        super();
-        Object.setPrototypeOf(this, Component.prototype);
-
-        this.shadowDOM = new ShadowDOM(DOM.instance, this, false);
-        this.shadow = this.attachShadow({mode: 'open'});
-
-        const templateId = this.getAttribute('template');
-        let template: HTMLTemplateElement;
-
-        if (templateId) {
-            template = document.getElementById(templateId) as HTMLTemplateElement;
-        } else {
-            template = Registry.instance.templates.getSynchronous(this.tagName.toLowerCase());
-        }
-
-        this.setAttribute('vsn-scope', '');
-        this.shadow.appendChild(template.content.cloneNode(true));
-        for (const child of Array.from(this.shadow.children)) {
-            child['shadowParent'] = this;
-        }
-        const slotPromises = [];
-        const tagsToSetup = [];
-        this.shadow.querySelectorAll('slot').forEach((slot) => {
-            const slotTagPromise = this.shadowDOM.buildTag(slot,false, SlotTag);
-            const promise = new Promise<SlotTag>((resolve, reject) => {
-                slot.addEventListener('slotchange', (e) => {
-                    slotTagPromise.then(async (slotTag) => {
-                        for (const child of slot.assignedNodes()) {
-                            const t = await this.shadowDOM.buildTag<SlottedTag>(child as HTMLElement, false, SlottedTag);
-                            await t?.slotted(slotTag);
-                            tagsToSetup.push(t);
-                        }
-                        resolve(slotTag);
-                    });
-                });
-            });
-            slotPromises.push(promise);
-        });
-        Promise.all(slotPromises).then(async (slotTags: SlotTag[]) => {
-            console.log('Building after slot setup', this);
-        });
-    }
-
-    async connectedCallback() {
-        //const tag = await this.shadowDOM.buildTag(this, true);
-        //tag.createScope(true);
-        console.log('Building from shadow', this.shadow);
-        await this.shadowDOM.buildFrom(this.shadow, true, true);
-        ///await tag.dom.resetBranch(tag);
-        //await tag.dom.setupTags([tag]);
-    }
-}

package/src/Configuration.ts

@@ -1,47 +0,0 @@
-import {VisionHelper} from "./helpers/VisionHelper";
-import {EventDispatcher} from "./EventDispatcher";
-
-export type ConfigurationValue = string | number | boolean | null | undefined;
-
-export class Configuration extends EventDispatcher {
-    protected static _instance: Configuration;
-    private readonly data: {[key: string]: ConfigurationValue};
-
-    constructor() {
-        super();
-        this.data = VisionHelper.window && window['$configuration'] || {};
-    }
-
-    public get(key: string, defaultValue: ConfigurationValue = null): ConfigurationValue {
-        return this.data[key] === undefined ? defaultValue : this.data[key];
-    }
-
-    public set(key: string, value: ConfigurationValue) {
-        const prev: ConfigurationValue = this.data[key];
-        this.data[key] = value;
-        this.dispatch(`change:${key}`, {
-            value: value,
-            previous: prev
-        });
-        this.dispatch('change', {
-            key: key,
-            value: value,
-            previous: prev
-        })
-    }
-
-    public static set(key: string, value: ConfigurationValue) {
-        Configuration.instance.set(key, value);
-    }
-
-    public static get(key: string, defaultValue: ConfigurationValue = null): ConfigurationValue {
-        return Configuration.instance.get(key, defaultValue);
-    }
-
-    public static get instance() {
-        if (!Configuration._instance)
-            Configuration._instance = new Configuration();
-
-        return Configuration._instance;
-    }
-}

package/src/Controller.ts

@@ -1,36 +0,0 @@
-import {Scope} from "./Scope";
-import {Tag} from "./Tag";
-import {ScopeObject} from "./Scope/ScopeObject";
-
-export abstract class Controller extends ScopeObject {
-    protected _scope: Scope;
-    protected _tag: Tag;
-    protected _element: HTMLElement;
-
-    constructor() {
-        super();
-        for (const k in this) {
-            if (this[k] as any instanceof Function) {
-                this.__properties__.push(k);
-            }
-        }
-    }
-
-    public get scope(): Scope {
-        return this._scope;
-    }
-
-    public get tag(): Tag {
-        return this._tag;
-    }
-
-    public get element(): HTMLElement {
-        return this._element;
-    }
-
-    public init(scope: Scope, tag: Tag, element: HTMLElement): void {
-        this._scope = scope;
-        this._tag = tag;
-        this._element = element;
-    }
-}