vasille 1.2.6 → 2.0.0

package/lib/interfaces/core.js

@@ -1,247 +0,0 @@
-// 
-import { Destroyable }             from "./destroyable.js";
-import { internalError, notFound } from "./errors";
-import { IValue }                  from "./ivalue.js";
-
-
-
-
-
-/**
- * Destroy all destroyable object fields
- * @param obj {Object<any, any>} Object to be iterated
- */
-export function $destroyObject (obj) {
-    for (let i in obj) {
-        if (obj.hasOwnProperty(i)) {
-            let prop = obj[i];
-            if (prop instanceof Destroyable && !(prop instanceof VasilleNode)) {
-                prop.$destroy();
-            }
-            delete obj[i];
-        }
-    }
-}
-
-/**
- * Represents a Vasille.js node
- * @implements Destroyable
- */
-export class VasilleNodePrivate extends Destroyable {
-    /**
-     * The encapsulated element
-     * @type {HTMLElement | Text | Comment}
-     * @see VasilleNode#coreEl
-     * @see VasilleNode#el
-     * @see VasilleNode#text
-     * @see VasilleNode#comment
-     */
-    $el;
-
-    /**
-     * The collection of attributes
-     * @type {Object<String, IValue>}
-     * @see VasilleNode#attr
-     */
-    $attrs = {};
-
-    /**
-     * The collection of style attributes
-     * @type {Object<String, IValue>}
-     * @see VasilleNode#style
-     */
-    $style = {};
-    /**
-     * The root node
-     * @type {INode}
-     */
-    root;
-
-    /**
-     * The this node
-     * @type {INode}
-     */
-    ts;
-
-    /**
-     * The app node
-     * @type {VasilleNode}
-     */
-    app;
-
-    /**
-     * A link to a parent node
-     * @type {VasilleNode}
-     */
-    parent;
-
-    /**
-     * The next node
-     * @type {?VasilleNode}
-     */
-    next;
-
-    /**
-     * The previous node
-     * @type {?VasilleNode}
-     */
-    prev;
-
-    constructor () {
-        super();
-
-        this.seal();
-    }
-
-    /**
-     * Gets the encapsulated element anyway
-     * @type {HTMLElement | Text | Comment}
-     * @see VasilleNode#$el
-     */
-    get coreEl () {
-        return this.$el;
-    }
-
-    /**
-     * Gets the encapsulated element if it is a html element, otherwise undefined
-     * @type {HTMLElement}
-     * @see VasilleNode#$el
-     */
-    get el () {
-        let el = this.coreEl;
-        if (el instanceof HTMLElement) {
-            return el;
-        }
-
-        throw internalError("wrong VasilleNode.$el() call");
-    }
-
-    /**
-     * Gets the encapsulated element if it is a html text node, otherwise undefined
-     * @type {Text}
-     * @see VasilleNode#$el
-     */
-    get text () {
-        let el = this.coreEl;
-        if (el instanceof Text) {
-            return el;
-        }
-
-        throw internalError("wrong VasilleNode.$text() call");
-    }
-
-    /**
-     * Gets the encapsulated element if it is a html comment, otherwise undefined
-     * @type {Comment}
-     * @see VasilleNode#$el
-     */
-    get comment () {
-        let el = this.coreEl;
-        if (el instanceof Comment) {
-            return el;
-        }
-
-        throw internalError("wrong VasilleNode.$comment() call");
-    }
-
-    /**
-     * Encapsulate element
-     * @param el {HTMLElement | Text | Comment} element to encapsulate
-     * @private
-     */
-    encapsulate (el) {
-        this.$el = el;
-        return this;
-    }
-
-    /**
-     * Pre-initializes the base of a node
-     * @param app {App} the app node
-     * @param rt {INode} The root node
-     * @param ts {INode} The this node
-     * @param before {?VasilleNode} VasilleNode to paste this after
-     */
-    preinit (app, rt, ts, before) {
-        this.app = app;
-        this.root = rt;
-        this.ts = ts;
-    }
-
-    /**
-     * Gets the component life attribute value
-     * @param field {string} attribute name
-     * @return {IValue}
-     */
-    attr (field) {
-        let v = this.$attrs[field];
-
-        if (v instanceof IValue) {
-            return v;
-        }
-
-        throw notFound("no such attribute: " + field);
-    }
-
-    /**
-     * Gets the component life style attribute
-     * @param field {Object<String, IValue>}
-     * @return {IValue<string>}
-     * @see VasilleNode#$style
-     */
-    style (field) {
-        let v = this.$style[field];
-
-        if (v instanceof IValue) {
-            return v;
-        }
-
-        throw notFound("no such style attribute: " + field);
-    }
-
-    /**
-     * Unlinks all bindings
-     */
-    $destroy () {
-        $destroyObject(this.$attrs);
-        $destroyObject(this.$style);
-        //$FlowFixMe
-        this.$el = null;
-        //$FlowFixMe
-        this.$attrs = null;
-        //$FlowFixMe
-        this.$style = null;
-        //$FlowFixMe
-        this.root = null;
-        //$FlowFixMe
-        this.ts = null;
-        //$FlowFixMe
-        this.app = null;
-        //$FlowFixMe
-        this.parent = null;
-        //$FlowFixMe
-        this.next = null;
-        //$FlowFixMe
-        this.prev = null;
-    }
-}
-
-/**
- * This class is symbolic
- */
-export class VasilleNode extends Destroyable {
-    /**
-     * @type {VasilleNodePrivate}
-     */
-    $;
-
-    /**
-     * Constructs a Vasille Node
-     * @param $ {VasilleNodePrivate}
-     */
-    constructor ($) {
-        super();
-        this.$ = $ || new VasilleNodePrivate;
-    }
-}
-
-//# sourceMappingURL=core.js.map

package/lib/interfaces/core.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/interfaces/core.js"],"names":[],"mappings":"GAAG,AAAK;AACR,AAAkD,AAAA;;;;;;;AAOlD,AAA0D,AAAA;AAC1D,AAAkD,AAAA;;;;;;;oCAOd,AAAA,AAAQ;;;;;;;;;;;;;;;;;;;;;;;;;QAyBpC,AAAA,AAAQ;;;;;;;WAOL,AAAA,AAAY;;;;;;;WAOZ,AAAA,AAAY;;;;;SAKd,AAAA,AAAO;;;;;;OAMT,AAAA,AAAO;;;;;;QAMN,AAAA,AAAK;;;;;;WAMF,AAAA,AAAO;;;;;;SAMT,AAAA,AAAc;;;;;;SAMd,AAAA,AAAc;;;;;;;;;;;;;kBAaL,AAAA,AAAQ;;;;;;;;;cASZ,AAAA,AAAa;;;;;;;;;;;;;;gBAcX,AAAA,AAAM;;;;;;;;;;;;;;mBAcH,AAAA,AAAS;;;;;;;;;;;;;;oBAcR,AAAA,AAAQ,EAAE,AAAA,AAAM;;;;;;;;;;;;iBAYnB,AAAA,AAAK,KAAK,AAAA,AAAO,KAAK,AAAA,AAAO,SAAS,AAAA,AAAc;;;;;;;;;;;gBAWrD,AAAA,AAAQ,EAAE,AAAA,AAAgB;;;;;;;;;;;;;;;;iBAgBzB,AAAA,AAAQ,EAAE,AAAA,AAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA4CrC,AAAA,AAAK;;;;;;mBAMQ,AAAA,AAAqB"}

package/lib/interfaces/destroyable.js

@@ -1,39 +0,0 @@
-// 
-
-/**
- * Mark an object which can be destroyed
- * @class
- */
-export class Destroyable {
-    seal () {
-        let $ = this;
-
-        for (let i in $) {
-            if (this.hasOwnProperty(i)) {
-                let config = Object.getOwnPropertyDescriptor($, i);
-
-                if (!config || config.configurable) {
-                    Object.defineProperty($, i, config?.set || config?.get ? {
-                        configurable: false,
-                        get: config?.get,
-                        set: config?.set,
-                        enumerable: config?.enumerable ?? false
-                    } : {
-                        value: $[i],
-                        configurable: false,
-                        writable: config?.writable ?? false,
-                        enumerable: config?.enumerable ?? false
-                    });
-                }
-            }
-        }
-    }
-    
-    /**
-     * Garbage collector method
-     */
-    $destroy () {
-    }
-}
-
-//# sourceMappingURL=destroyable.js.map

package/lib/interfaces/destroyable.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/interfaces/destroyable.js"],"names":[],"mappings":"GAAG,AAAK;;;;;;;;cAQM,AAAA,AAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;gBA0BN,AAAA,AAAM"}

package/lib/interfaces/errors.js

@@ -1,49 +0,0 @@
-// 
-const reportIt = "Report it here: https://gitlab.com/vasille-js/vasille-js/-/issues";
-
-/**
- * @return {string}
- */
-export function notOverwritten () {
-    console.error("Vasille.js: Internal error", "Must be overwritten", reportIt);
-    return "not-overwritten";
-}
-
-/**
- * @return {string}
- */
-export function internalError (msg) {
-    console.error("Vasille.js: Internal error", msg, reportIt);
-    return "internal-error";
-}
-
-/**
- * @return {string}
- */
-export function userError (msg, err) {
-    console.error("Vasille.js: User error", msg);
-    return err;
-}
-
-/**
- * @return {string}
- */
-export function typeError (msg) {
-    return userError(msg, "type-error");
-}
-
-/**
- * @return {string}
- */
-export function notFound (msg) {
-    return userError(msg, "not-found");
-}
-
-/**
- * @return {string}
- */
-export function wrongBinding (msg) {
-    return userError(msg, "wrong-binding");
-}
-
-//# sourceMappingURL=errors.js.map

package/lib/interfaces/errors.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/interfaces/errors.js"],"names":[],"mappings":"GAAG,AAAK;;;;;;kCAM0B,AAAA,AAAQ;;;;;;;;mCAQP,AAAA,AAAQ,EAAE,AAAA,AAAQ;;;;;;;;+BAQtB,AAAA,AAAQ,MAAM,AAAA,AAAQ,EAAE,AAAA,AAAQ;;;;;;;;+BAQhC,AAAA,AAAQ,EAAE,AAAA,AAAQ;;;;;;;8BAOnB,AAAA,AAAQ,EAAE,AAAA,AAAQ;;;;;;;kCAOd,AAAA,AAAQ,EAAE,AAAA,AAAQ"}

package/lib/interfaces/ibind.js

@@ -1,31 +0,0 @@
-// 
-import { notOverwritten } from "./errors";
-import { IValue }         from "./ivalue.js";
-
-
-
-/**
- * Mark an object which can be bound
- * @interface
- */
-export class IBind extends IValue {
-    /**
-     * Ensure the binding to be bound
-     * @return a pointer to this
-     * @throws must be overwritten
-     */
-    link () {
-        throw notOverwritten();
-    }
-
-    /**
-     * Ensure the binding to be unbound
-     * @return a pointer to this
-     * @throws must be overwritten
-     */
-    unlink () {
-        throw notOverwritten();
-    }
-}
-
-//# sourceMappingURL=ibind.js.map

package/lib/interfaces/ibind.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/interfaces/ibind.js"],"names":[],"mappings":"GAAG,AAAK;;;;;;;;;;iCAUyB,AAAK;;;;;;YAM1B,AAAA,AAAM;;;;;;;;;cASJ,AAAA,AAAM"}

package/lib/interfaces/idefinition.js

@@ -1,64 +0,0 @@
-// 
-
-import { IValue } from "../index";
-
-
-
-/**
- * Represent a function encapsulated to a class
- */
-export class Callable {
-    /**
-     * Function which will resolve value
-     * @type {Function}
-     */
-    func;
-
-    /**
-     * Encapsulates a function
-     * @param func {Function} function to encapsulate
-     */
-    constructor (func) {
-        Object.defineProperty(this, 'func', {
-            value: func,
-            writable: false,
-            configurable: false
-        });
-    }
-}
-
-/**
- * Check the type of value
- * @param v {*} value
- * @param t {Function} type constructor
- * @return {boolean}
- */
-export function checkType (v, t) {
-    if (v instanceof IValue) {
-        v = v.$;
-    }
-    return (v instanceof t) || v === null ||
-        (typeof v === "number" && t === Number) ||
-        (typeof v === "string" && t === String) ||
-        (typeof v === "boolean" && t === Boolean);
-}
-
-/**
- * Check if a type is a subtype
- * @param parent {Function} potential superclass
- * @param child {Function} potential subclass
- * @return {boolean}
- */
-export function isSubclassOf (parent, child) {
-    let it = child;
-    let isParent = false;
-
-    while (it && !isParent) {
-        isParent = it.prototype instanceof parent;
-        it = it.prototype;
-    }
-
-    return isParent;
-}
-
-//# sourceMappingURL=idefinition.js.map

package/lib/interfaces/idefinition.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/interfaces/idefinition.js"],"names":[],"mappings":"GAAG,AAAK;;;;;;;;;;;;;;SAcC,AAAA,AAAU;;;;;;sBAMG,AAAA,AAAU;;;;;;;;;;;;;;;6BAeH,AAAA,AAAK,IAAI,AAAA,AAAU,EAAE,AAAA,AAAS;;;;;;;;;;;;;;;;qCAgBtB,AAAA,AAAU,QAAQ,AAAA,AAAU,EAAE,AAAA,AAAS;WACjE,AAAA,AAAU"}

package/lib/interfaces/ivalue.js

@@ -1,60 +0,0 @@
-// 
-import { Destroyable }    from "./destroyable.js";
-import { notOverwritten } from "./errors";
-
-
-
-/**
- * A interface which describes a value
- * @interface
- * @extends Destroyable
- */
-export class IValue extends Destroyable {
-
-    /**
-     * Used for strong type checking
-     * @type {?Function}
-     */
-    type = null;
-
-    /**
-     * Gets the encapsulated value
-     * @return {*} Must return a value
-     * @throws Must be overwritten
-     */
-    get $ () {
-        throw notOverwritten();
-    }
-
-    /**
-     * Sets the encapsulated value
-     * @param value {*} Reference to encapsulate
-     * @return {IValue} A pointer to this
-     * @throws Must be overwritten
-     */
-    set $ (value) {
-        throw notOverwritten();
-    }
-
-    /**
-     * Add a new handler to value change
-     * @param handler {Function} The handler to add
-     * @return {IValue} a pointer to this
-     * @throws Must be overwritten
-     */
-    on (handler) {
-        throw notOverwritten();
-    }
-
-    /**
-     * Removes a handler of value change
-     * @param handler {Function} the handler to remove
-     * @return {IValue} a pointer to this
-     * @throws Must be overwritten
-     */
-    off (handler) {
-        throw notOverwritten();
-    }
-}
-
-//# sourceMappingURL=ivalue.js.map

package/lib/interfaces/ivalue.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/interfaces/ivalue.js"],"names":[],"mappings":"GAAG,AAAK;;;;;;;;;;;mBAWW,AAAG;;;;;;SAMb,AAAA,AAAW;;;;;;;aAOP,AAAA,AAAG;;;;;;;;;;iBAUC,AAAA,AAAG,EAAE,AAAA,AAAM;;;;;;;;;;gBAUZ,AAAA,AAAU,EAAE,AAAA,AAAM;;;;;;;;;;iBAUjB,AAAA,AAAU,EAAE,AAAA,AAAM"}