vasille 1.2.9 → 2.0.3

package/lib/core/slot.js

@@ -0,0 +1,47 @@
+/**
+ * Component slot
+ * @class Slot
+ */
+export class Slot {
+    /**
+     * Sets the runner
+     * @param func {function} the function to run
+     */
+    insert(func) {
+        this.runner = func;
+    }
+    /**
+     * @param a0 {Fragment} node to paste content
+     * @param a1 {*} 1st argument
+     * @param a2 {*} 2nd argument
+     * @param a3 {*} 3rd argument
+     * @param a4 {*} 4th argument
+     * @param a5 {*} 5th argument
+     * @param a6 {*} 6th argument
+     * @param a7 {*} 7th argument
+     * @param a8 {*} 8th argument
+     * @param a9 {*} 9th argument
+     */
+    release(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) {
+        if (this.runner) {
+            this.runner(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
+        }
+    }
+    /**
+     * Predefine a handler for a slot
+     * @param func {function(node : Fragment)} Function to run if no handler specified
+     * @param a0 {Fragment} node to paste content
+     * @param a1 {*} 1st argument
+     * @param a2 {*} 2nd argument
+     * @param a3 {*} 3rd argument
+     * @param a4 {*} 4th argument
+     * @param a5 {*} 5th argument
+     * @param a6 {*} 6th argument
+     * @param a7 {*} 7th argument
+     * @param a8 {*} 8th argument
+     * @param a9 {*} 9th argument
+     */
+    predefine(func, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) {
+        (this.runner || func)(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
+    }
+}

package/lib/index.js

@@ -1,22 +1,27 @@
-import { Expression }                                      from "./bind.js";
-import { Destroyable }                                     from "./interfaces/destroyable.js";
-import { IBind }                                           from "./interfaces/ibind.js";
-import { IValue }                                          from "./interfaces/ivalue.js";
-import { ArrayModel, MapModel, ObjectModel, SetModel }     from "./models.js";
-import { App, INode, Extension, Tag, TextNode, Component } from "./node.js";
-import { Pointer, Reference }                              from "./value.js";
-import { ArrayView, MapView, ObjectView, SetView }         from "./views.js";
-
-
-
-export {
-    Expression,
-    Destroyable,
-    IBind, IValue,
-    ArrayModel, MapModel, ObjectModel, SetModel,
-    App, INode, Tag, Extension, TextNode, Component,
-    Pointer, Reference,
-    ArrayView, MapView, ObjectView, SetView
-};
-
-//# sourceMappingURL=index.js.map
+import { Destroyable } from "./core/destroyable";
+import { Executor, InstantExecutor, TimeoutExecutor } from "./core/executor";
+import { Reactive } from "./core/core";
+import { IValue } from "./core/ivalue";
+import { Signal } from "./core/signal";
+import { Slot } from "./core/slot";
+import { ArrayModel } from "./models/array-model";
+import { Listener } from "./models/listener";
+import { MapModel } from "./models/map-model";
+import { ObjectModel } from "./models/object-model";
+import { SetModel } from "./models/set-model";
+import { App, AppNode } from "./node/app";
+import { Interceptor, InterceptorNode } from "./node/interceptor";
+import { Component, Extension, Fragment, INode, Tag } from "./node/node";
+import { Expression } from "./value/expression";
+import { Mirror } from "./value/mirror";
+import { Pointer } from "./value/pointer";
+import { Reference } from "./value/reference";
+import { ArrayView } from "./views/array-view";
+import { BaseView } from "./views/base-view";
+import { MapView } from "./views/map-view";
+import { ObjectView } from "./views/object-view";
+import { RepeatNode } from "./views/repeat-node";
+import { Repeater } from "./views/repeater";
+import { SetView } from "./views/set-view";
+import { Binding } from "./binding/binding";
+export { Destroyable, IValue, Reference, Mirror, Pointer, ArrayModel, MapModel, ObjectModel, SetModel, RepeatNode, Repeater, BaseView, Listener, ArrayView, MapView, ObjectView, SetView, Fragment, INode, Tag, Component, Extension, AppNode, App, Executor, InstantExecutor, TimeoutExecutor, Signal, Slot, Interceptor, InterceptorNode, Expression, Binding, Reactive, };

package/lib/models/array-model.js

@@ -0,0 +1,208 @@
+import { Listener } from "./listener";
+/**
+ * Model based on Array class
+ * @extends Array
+ * @implements IModel
+ */
+export class ArrayModel extends Array {
+    /**
+     * @param data {Array} input data
+     */
+    constructor(data = []) {
+        super();
+        Object.defineProperty(this, 'listener', {
+            value: new 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;
+    }
+    enableReactivity() {
+        this.listener.enableReactivity();
+    }
+    disableReactivity() {
+        this.listener.disableReactivity();
+    }
+}

package/lib/models/listener.js

@@ -0,0 +1,130 @@
+/**
+ * Represent a listener for a model
+ * @class Listener
+ */
+export 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;
+    }
+}

package/lib/models/map-model.js

@@ -0,0 +1,66 @@
+import { Listener } from "./listener";
+/**
+ * A Map based memory
+ * @class MapModel
+ * @extends Map
+ * @implements IModel
+ */
+export class MapModel extends Map {
+    /**
+     * Constructs a map model
+     * @param map {[*, *][]} input data
+     */
+    constructor(map = []) {
+        super();
+        Object.defineProperty(this, 'listener', {
+            value: new 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();
+    }
+}

package/lib/models/model.js

@@ -0,0 +1 @@
+export {};

package/lib/models/object-model.js

@@ -0,0 +1,78 @@
+import { Listener } from "./listener";
+/**
+ * Object based model
+ * @extends Object
+ */
+export class ObjectModel extends Object {
+    /**
+     * Constructs a object model
+     * @param obj {Object} input data
+     */
+    constructor(obj = {}) {
+        super();
+        Object.defineProperty(this, 'listener', {
+            value: new Listener,
+            writable: false,
+            configurable: false
+        });
+        for (const i in obj) {
+            Object.defineProperty(this, 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) {
+        const ts = this;
+        return ts[key];
+    }
+    /**
+     * Sets an object property value
+     * @param key {string} property name
+     * @param v {*} property value
+     * @return {ObjectModel} a pointer to this
+     */
+    set(key, v) {
+        const ts = this;
+        // eslint-disable-next-line no-prototype-builtins
+        if (ts.hasOwnProperty(key)) {
+            this.listener.emitRemoved(key, ts[key]);
+            ts[key] = v;
+        }
+        else {
+            Object.defineProperty(ts, key, {
+                value: v,
+                configurable: true,
+                writable: true,
+                enumerable: true
+            });
+        }
+        this.listener.emitAdded(key, ts[key]);
+        return this;
+    }
+    /**
+     * Deletes an object property
+     * @param key {string} property name
+     */
+    delete(key) {
+        const ts = this;
+        if (ts[key]) {
+            this.listener.emitRemoved(key, ts[key]);
+            delete ts[key];
+        }
+    }
+    enableReactivity() {
+        this.listener.enableReactivity();
+    }
+    disableReactivity() {
+        this.listener.disableReactivity();
+    }
+}

package/lib/models/set-model.js

@@ -0,0 +1,62 @@
+import { Listener } from "./listener";
+/**
+ * A Set based model
+ * @class SetModel
+ * @extends Set
+ * @implements IModel
+ */
+export 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,
+            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();
+    }
+}

package/lib/node/app.js

@@ -0,0 +1,39 @@
+import { instantExecutor, timeoutExecutor } from "../core/executor";
+import { INode } from "./node";
+/**
+ * Application Node
+ * @class AppNode
+ * @extends INode
+ */
+export class AppNode extends INode {
+    /**
+     * @param options {Object} Application options
+     */
+    constructor(options) {
+        super();
+        this.$run = (options === null || options === void 0 ? void 0 : options.executor) || ((options === null || options === void 0 ? void 0 : options.freezeUi) === false ? timeoutExecutor : instantExecutor);
+        this.$debugUi = (options === null || options === void 0 ? void 0 : options.debugUi) || false;
+    }
+}
+/**
+ * Represents a Vasille.js application
+ * @class App
+ * @extends AppNode
+ */
+export class App extends AppNode {
+    /**
+     * Constructs an app node
+     * @param node {Element} The root of application
+     * @param options {Object} Application options
+     */
+    constructor(node, options) {
+        super(options);
+        this.$.node = node;
+        this.$preinit(this, this);
+        this.$seal();
+    }
+    $$appendNode(node) {
+        const $ = this.$;
+        $.app.$run.appendChild($.node, node);
+    }
+}