vasille 2.3.0 → 2.3.1

package/lib-node/models/array-model.js

@@ -0,0 +1,218 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArrayModel = void 0;
+const listener_1 = require("./listener");
+/**
+ * Model based on Array class
+ * @extends Array
+ * @implements IModel
+ */
+class ArrayModel extends Array {
+    /**
+     * @param data {Array} input data
+     */
+    constructor(data = []) {
+        super();
+        Object.defineProperty(this, 'listener', {
+            value: new listener_1.Listener,
+            writable: false,
+            configurable: false
+        });
+        for (let i = 0; i < data.length; i++) {
+            super.push(data[i]);
+        }
+    }
+    /* Array members */
+    /**
+     * Gets the last item of array
+     * @return {*} the last item of array
+     */
+    get last() {
+        return this.length ? this[this.length - 1] : null;
+    }
+    /**
+     * Calls Array.fill and notify about changes
+     * @param value {*} value to fill with
+     * @param start {?number} begin index
+     * @param end {?number} end index
+     */
+    fill(value, start, end) {
+        if (!start) {
+            start = 0;
+        }
+        if (!end) {
+            end = this.length;
+        }
+        for (let i = start; i < end; i++) {
+            this.listener.emitRemoved(this[i], this[i]);
+            this[i] = value;
+            this.listener.emitAdded(value, value);
+        }
+        return this;
+    }
+    /**
+     * Calls Array.pop and notify about changes
+     * @return {*} removed value
+     */
+    pop() {
+        const v = super.pop();
+        if (v !== undefined) {
+            this.listener.emitRemoved(v, v);
+        }
+        return v;
+    }
+    /**
+     * Calls Array.push and notify about changes
+     * @param items {...*} values to push
+     * @return {number} new length of array
+     */
+    push(...items) {
+        items.forEach(item => {
+            this.listener.emitAdded(item, item);
+            super.push(item);
+        });
+        return this.length;
+    }
+    /**
+     * Calls Array.shift and notify about changed
+     * @return {*} the shifted value
+     */
+    shift() {
+        const v = super.shift();
+        if (v !== undefined) {
+            this.listener.emitRemoved(v, v);
+        }
+        return v;
+    }
+    /**
+     * Calls Array.splice and notify about changed
+     * @param start {number} start index
+     * @param deleteCount {?number} delete count
+     * @param items {...*}
+     * @return {ArrayModel} a pointer to this
+     */
+    splice(start, deleteCount, ...items) {
+        start = Math.min(start, this.length);
+        deleteCount = deleteCount || this.length - start;
+        const before = this[start + deleteCount];
+        for (let i = 0; i < deleteCount; i++) {
+            const index = start + deleteCount - i - 1;
+            if (this[index] !== undefined) {
+                this.listener.emitRemoved(this[index], this[index]);
+            }
+        }
+        for (let i = 0; i < items.length; i++) {
+            this.listener.emitAdded(before, items[i]);
+        }
+        return new ArrayModel(super.splice(start, deleteCount, ...items));
+    }
+    /**
+     * Calls Array.unshift and notify about changed
+     * @param items {...*} values to insert
+     * @return {number} the length after prepend
+     */
+    unshift(...items) {
+        for (let i = 0; i < items.length; i++) {
+            this.listener.emitAdded(this[i], items[i]);
+        }
+        return super.unshift(...items);
+    }
+    /**
+     * Inserts a value to the end of array
+     * @param v {*} value to insert
+     */
+    append(v) {
+        this.listener.emitAdded(null, v);
+        super.push(v);
+        return this;
+    }
+    /**
+     * Clears array
+     * @return {this} a pointer to this
+     */
+    clear() {
+        this.forEach(v => {
+            this.listener.emitRemoved(v, v);
+        });
+        super.splice(0);
+        return this;
+    }
+    /**
+     * Inserts a value to position `index`
+     * @param index {number} index to insert value
+     * @param v {*} value to insert
+     * @return {this} a pointer to this
+     */
+    insert(index, v) {
+        this.listener.emitAdded(this[index], v);
+        super.splice(index, 0, v);
+        return this;
+    }
+    /**
+     * Inserts a value to the beginning of array
+     * @param v {*} value to insert
+     * @return {this} a pointer to this
+     */
+    prepend(v) {
+        this.listener.emitAdded(this[0], v);
+        super.unshift(v);
+        return this;
+    }
+    /**
+     * Removes a value from an index
+     * @param index {number} index of value to remove
+     * @return {this} a pointer to this
+     */
+    removeAt(index) {
+        if (index > 0 && index < this.length) {
+            this.listener.emitRemoved(this[index], this[index]);
+            super.splice(index, 1);
+        }
+        return this;
+    }
+    /**
+     * Removes the first value of array
+     * @return {this} a pointer to this
+     */
+    removeFirst() {
+        if (this.length) {
+            this.listener.emitRemoved(this[0], this[0]);
+            super.shift();
+        }
+        return this;
+    }
+    /**
+     * Removes the ast value of array
+     * @return {this} a pointer to this
+     */
+    removeLast() {
+        const last = this.last;
+        if (last != null) {
+            this.listener.emitRemoved(this[this.length - 1], last);
+            super.pop();
+        }
+        return this;
+    }
+    /**
+     * Remove the first occurrence of value
+     * @param v {*} value to remove
+     * @return {this}
+     */
+    removeOne(v) {
+        this.removeAt(this.indexOf(v));
+        return this;
+    }
+    replace(at, with_) {
+        this.listener.emitAdded(this[at], with_);
+        this.listener.emitRemoved(this[at], this[at]);
+        this[at] = with_;
+        return this;
+    }
+    enableReactivity() {
+        this.listener.enableReactivity();
+    }
+    disableReactivity() {
+        this.listener.disableReactivity();
+    }
+}
+exports.ArrayModel = ArrayModel;

package/lib-node/models/listener.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Listener = void 0;
+/**
+ * Represent a listener for a model
+ * @class Listener
+ */
+class Listener {
+    constructor() {
+        Object.defineProperties(this, {
+            onAdded: {
+                value: new Set,
+                writable: false,
+                configurable: false
+            },
+            onRemoved: {
+                value: new Set,
+                writable: false,
+                configurable: false
+            },
+            frozen: {
+                value: false,
+                writable: true,
+                configurable: false
+            },
+            queue: {
+                value: [],
+                writable: false,
+                configurable: false
+            }
+        });
+    }
+    /**
+     * Exclude the repeated operation in queue
+     * @private
+     */
+    excludeRepeat(index) {
+        this.queue.forEach((item, i) => {
+            if (item.index === index) {
+                this.queue.splice(i, 1);
+                return true;
+            }
+        });
+        return false;
+    }
+    /**
+     * Emits added event to listeners
+     * @param index {*} index of value
+     * @param value {*} value of added item
+     */
+    emitAdded(index, value) {
+        if (this.frozen) {
+            if (!this.excludeRepeat(index)) {
+                this.queue.push({ sign: true, index, value });
+            }
+        }
+        else {
+            this.onAdded.forEach(handler => {
+                handler(index, value);
+            });
+        }
+    }
+    /**
+     * Emits removed event to listeners
+     * @param index {*} index of removed value
+     * @param value {*} value of removed item
+     */
+    emitRemoved(index, value) {
+        if (this.frozen) {
+            if (!this.excludeRepeat(index)) {
+                this.queue.push({ sign: false, index, value });
+            }
+        }
+        else {
+            this.onRemoved.forEach(handler => {
+                handler(index, value);
+            });
+        }
+    }
+    /**
+     * Adds a handler to added event
+     * @param handler {function} function to run on event emitting
+     */
+    onAdd(handler) {
+        this.onAdded.add(handler);
+    }
+    /**
+     * Adds a handler to removed event
+     * @param handler {function} function to run on event emitting
+     */
+    onRemove(handler) {
+        this.onRemoved.add(handler);
+    }
+    /**
+     * Removes an handler from added event
+     * @param handler {function} handler to remove
+     */
+    offAdd(handler) {
+        this.onAdded.delete(handler);
+    }
+    /**
+     * Removes an handler form removed event
+     * @param handler {function} handler to remove
+     */
+    offRemove(handler) {
+        this.onRemoved.delete(handler);
+    }
+    /**
+     * Run all queued operation and enable reactivity
+     */
+    enableReactivity() {
+        this.queue.forEach(item => {
+            if (item.sign) {
+                this.onAdded.forEach(handler => {
+                    handler(item.index, item.value);
+                });
+            }
+            else {
+                this.onRemoved.forEach(handler => {
+                    handler(item.index, item.value);
+                });
+            }
+        });
+        this.queue.splice(0);
+        this.frozen = false;
+    }
+    /**
+     * Disable the reactivity and enable the queue
+     */
+    disableReactivity() {
+        this.frozen = true;
+    }
+}
+exports.Listener = Listener;

package/lib-node/models/map-model.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MapModel = void 0;
+const listener_1 = require("./listener");
+/**
+ * A Map based memory
+ * @class MapModel
+ * @extends Map
+ * @implements IModel
+ */
+class MapModel extends Map {
+    /**
+     * Constructs a map model
+     * @param map {[*, *][]} input data
+     */
+    constructor(map = []) {
+        super();
+        Object.defineProperty(this, 'listener', {
+            value: new listener_1.Listener,
+            writable: false,
+            configurable: false
+        });
+        map.forEach(([key, value]) => {
+            super.set(key, value);
+        });
+    }
+    /**
+     * Calls Map.clear and notify abut changes
+     */
+    clear() {
+        this.forEach((value, key) => {
+            this.listener.emitRemoved(key, value);
+        });
+        super.clear();
+    }
+    /**
+     * Calls Map.delete and notify abut changes
+     * @param key {*} key
+     * @return {boolean} true if removed something, otherwise false
+     */
+    delete(key) {
+        const tmp = super.get(key);
+        if (tmp) {
+            this.listener.emitRemoved(key, tmp);
+        }
+        return super.delete(key);
+    }
+    /**
+     * Calls Map.set and notify abut changes
+     * @param key {*} key
+     * @param value {*} value
+     * @return {MapModel} a pointer to this
+     */
+    set(key, value) {
+        const tmp = super.get(key);
+        if (tmp) {
+            this.listener.emitRemoved(key, tmp);
+        }
+        super.set(key, value);
+        this.listener.emitAdded(key, value);
+        return this;
+    }
+    enableReactivity() {
+        this.listener.enableReactivity();
+    }
+    disableReactivity() {
+        this.listener.disableReactivity();
+    }
+}
+exports.MapModel = MapModel;

package/lib-node/models/model.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib-node/models/object-model.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObjectModel = void 0;
+const listener_1 = require("./listener");
+/**
+ * Object based model
+ * @extends Object
+ */
+class ObjectModel extends Object {
+    /**
+     * Constructs a object model
+     * @param obj {Object} input data
+     */
+    constructor(obj = {}) {
+        super();
+        this.container = Object.create(null);
+        Object.defineProperty(this, 'listener', {
+            value: new listener_1.Listener,
+            writable: false,
+            configurable: false
+        });
+        for (const i in obj) {
+            Object.defineProperty(this.container, i, {
+                value: obj[i],
+                configurable: true,
+                writable: true,
+                enumerable: true
+            });
+            this.listener.emitAdded(i, obj[i]);
+        }
+    }
+    /**
+     * Gets a value of a field
+     * @param key {string}
+     * @return {*}
+     */
+    get(key) {
+        return this.container[key];
+    }
+    /**
+     * Sets an object property value
+     * @param key {string} property name
+     * @param v {*} property value
+     * @return {ObjectModel} a pointer to this
+     */
+    set(key, v) {
+        if (Reflect.has(this.container, key)) {
+            this.listener.emitRemoved(key, this.container[key]);
+            this.container[key] = v;
+        }
+        else {
+            Object.defineProperty(this.container, key, {
+                value: v,
+                configurable: true,
+                writable: true,
+                enumerable: true
+            });
+        }
+        this.listener.emitAdded(key, this.container[key]);
+        return this;
+    }
+    get values() {
+        return this.container;
+    }
+    /**
+     * Deletes an object property
+     * @param key {string} property name
+     */
+    delete(key) {
+        if (this.container[key]) {
+            this.listener.emitRemoved(key, this.container[key]);
+            delete this.container[key];
+        }
+    }
+    enableReactivity() {
+        this.listener.enableReactivity();
+    }
+    disableReactivity() {
+        this.listener.disableReactivity();
+    }
+}
+exports.ObjectModel = ObjectModel;

package/lib-node/models/set-model.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SetModel = void 0;
+const listener_1 = require("./listener");
+/**
+ * A Set based model
+ * @class SetModel
+ * @extends Set
+ * @implements IModel
+ */
+class SetModel extends Set {
+    /**
+     * Constructs a set model based on a set
+     * @param set {Set} input data
+     */
+    constructor(set = []) {
+        super();
+        Object.defineProperty(this, 'listener', {
+            value: new listener_1.Listener,
+            writable: false,
+            configurable: false
+        });
+        set.forEach(item => {
+            super.add(item);
+        });
+    }
+    /**
+     * Calls Set.add and notify abut changes
+     * @param value {*} value
+     * @return {this} a pointer to this
+     */
+    add(value) {
+        if (!super.has(value)) {
+            this.listener.emitAdded(value, value);
+            super.add(value);
+        }
+        return this;
+    }
+    /**
+     * Calls Set.clear and notify abut changes
+     */
+    clear() {
+        this.forEach(item => {
+            this.listener.emitRemoved(item, item);
+        });
+        super.clear();
+    }
+    /**
+     * Calls Set.delete and notify abut changes
+     * @param value {*}
+     * @return {boolean} true if a value was deleted, otherwise false
+     */
+    delete(value) {
+        if (super.has(value)) {
+            this.listener.emitRemoved(value, value);
+        }
+        return super.delete(value);
+    }
+    enableReactivity() {
+        this.listener.enableReactivity();
+    }
+    disableReactivity() {
+        this.listener.disableReactivity();
+    }
+}
+exports.SetModel = SetModel;

package/lib-node/node/app.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Portal = exports.App = exports.AppNode = void 0;
+const node_1 = require("./node");
+/**
+ * Application Node
+ * @class AppNode
+ * @extends INode
+ */
+class AppNode extends node_1.INode {
+    /**
+     * @param input
+     */
+    constructor(input) {
+        super(input);
+        this.debugUi = input.debugUi || false;
+        this.$seal();
+    }
+}
+exports.AppNode = AppNode;
+/**
+ * Represents a Vasille.js application
+ * @class App
+ * @extends AppNode
+ */
+class App extends AppNode {
+    /**
+     * Constructs an app node
+     * @param node {Element} The root of application
+     * @param input
+     */
+    constructor(node, input) {
+        super(input);
+        this.$.node = node;
+        this.preinit(this, this);
+        this.init();
+        this.$seal();
+    }
+    appendNode(node) {
+        this.$.node.appendChild(node);
+    }
+}
+exports.App = App;
+class Portal extends AppNode {
+    constructor(input) {
+        super(input);
+        this.$.node = input.node;
+        this.$seal();
+    }
+    appendNode(node) {
+        this.$.node.appendChild(node);
+    }
+}
+exports.Portal = Portal;