vasille 1.2.9 → 2.0.0

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,38 @@
+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);
+    }
+}
+/**
+ * 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);
+    }
+}

package/lib/node/interceptor.js

@@ -0,0 +1,83 @@
+import { Extension } from "./node";
+import { Destroyable } from "../core/destroyable";
+import { Signal } from "../core/signal";
+import { Slot } from "../core/slot";
+/**
+ * Interceptor is designed to connect signals & methods of children elements
+ * @class Interceptor
+ * @extends Destroyable
+ */
+export class Interceptor extends Destroyable {
+    constructor() {
+        super(...arguments);
+        /**
+         * Set of signals
+         * @type Set
+         */
+        this.signals = new Set;
+        /**
+         * Set of handlers
+         * @type Set
+         */
+        this.handlers = new Set;
+    }
+    /**
+     * Connect a signal or a handler
+     * @param thing {Signal | function}
+     */
+    connect(thing) {
+        // interceptor will connect signals and handlers together
+        if (thing instanceof Signal) {
+            this.handlers.forEach(handler => {
+                thing.subscribe(handler);
+            });
+            this.signals.add(thing);
+        }
+        else {
+            this.signals.forEach(signal => {
+                signal.subscribe(thing);
+            });
+            this.handlers.add(thing);
+        }
+    }
+    /**
+     * Disconnect a handler from signals
+     * @param handler {function}
+     */
+    disconnect(handler) {
+        this.signals.forEach(signal => {
+            signal.unsubscribe(handler);
+        });
+    }
+    $destroy() {
+        super.$destroy();
+        this.signals.forEach(signal => {
+            this.handlers.forEach(handler => {
+                signal.unsubscribe(handler);
+            });
+        });
+    }
+}
+/**
+ * Interceptor node to implement directly to vasille DOM
+ * @class InterceptorNode
+ * @extends Extension
+ */
+export class InterceptorNode extends Extension {
+    constructor() {
+        super(...arguments);
+        /**
+         * Internal interceptor
+         * @type Interceptor
+         */
+        this.interceptor = new Interceptor;
+        /**
+         * The default slot of node
+         * @type Slot
+         */
+        this.slot = new Slot;
+    }
+    $compose() {
+        this.slot.release(this, this.interceptor);
+    }
+}