vasille 2.2.2 → 2.3.2

package/lib-node/core/core.js

@@ -0,0 +1,243 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Reactive = exports.ReactivePrivate = exports.current = void 0;
+const destroyable_js_1 = require("./destroyable.js");
+const errors_1 = require("./errors");
+const expression_1 = require("../value/expression");
+const reference_1 = require("../value/reference");
+const pointer_1 = require("../value/pointer");
+const mirror_1 = require("../value/mirror");
+exports.current = null;
+const currentStack = [];
+function stack(node) {
+    currentStack.push(exports.current);
+    exports.current = node;
+}
+function unstack() {
+    exports.current = currentStack.pop();
+}
+/**
+ * Private stuff of a reactive object
+ * @class ReactivePrivate
+ * @extends Destroyable
+ */
+class ReactivePrivate extends destroyable_js_1.Destroyable {
+    constructor() {
+        super();
+        /**
+         * A list of user-defined values
+         * @type {Set}
+         */
+        this.watch = new Set;
+        /**
+         * A list of user-defined bindings
+         * @type {Set}
+         */
+        this.bindings = new Set;
+        /**
+         * A list of user defined models
+         */
+        this.models = new Set;
+        /**
+         * Reactivity switch state
+         * @type {boolean}
+         */
+        this.enabled = true;
+        /**
+         * The frozen state of object
+         * @type {boolean}
+         */
+        this.frozen = false;
+        this.$seal();
+    }
+    $destroy() {
+        this.watch.forEach(value => value.$destroy());
+        this.watch.clear();
+        this.bindings.forEach(binding => binding.$destroy());
+        this.bindings.clear();
+        this.models.forEach(model => model.disableReactivity());
+        this.models.clear();
+        this.freezeExpr && this.freezeExpr.$destroy();
+        this.onDestroy && this.onDestroy();
+        super.$destroy();
+    }
+}
+exports.ReactivePrivate = ReactivePrivate;
+/**
+ * A reactive object
+ * @class Reactive
+ * @extends Destroyable
+ */
+class Reactive extends destroyable_js_1.Destroyable {
+    constructor(input, $) {
+        super();
+        this.input = input;
+        this.$ = $ || new ReactivePrivate;
+        this.$seal();
+    }
+    /**
+     * Get parent node
+     */
+    get parent() {
+        return this.$.parent;
+    }
+    /**
+     * Create a reference
+     * @param value {*} value to reference
+     */
+    ref(value) {
+        const $ = this.$;
+        const ref = new reference_1.Reference(value);
+        $.watch.add(ref);
+        return ref;
+    }
+    /**
+     * Create a mirror
+     * @param value {IValue} value to mirror
+     */
+    mirror(value) {
+        const mirror = new mirror_1.Mirror(value, false);
+        this.$.watch.add(mirror);
+        return mirror;
+    }
+    /**
+     * Create a forward-only mirror
+     * @param value {IValue} value to mirror
+     */
+    forward(value) {
+        const mirror = new mirror_1.Mirror(value, true);
+        this.$.watch.add(mirror);
+        return mirror;
+    }
+    /**
+     * Creates a pointer
+     * @param value {*} default value to point
+     * @param forwardOnly {boolean} forward only sync
+     */
+    point(value, forwardOnly = false) {
+        const $ = this.$;
+        const pointer = new pointer_1.Pointer(value, forwardOnly);
+        $.watch.add(pointer);
+        return pointer;
+    }
+    /**
+     * Register a model
+     * @param model
+     */
+    register(model) {
+        this.$.models.add(model);
+        return model;
+    }
+    /**
+     * Creates a watcher
+     * @param func {function} function to run on any argument change
+     * @param values
+     */
+    watch(func, ...values) {
+        const $ = this.$;
+        $.watch.add(new expression_1.Expression(func, !this.$.frozen, ...values));
+    }
+    /**
+     * Creates a computed value
+     * @param func {function} function to run on any argument change
+     * @param values
+     * @return {IValue} the created ivalue
+     */
+    expr(func, ...values) {
+        const res = new expression_1.Expression(func, !this.$.frozen, ...values);
+        const $ = this.$;
+        $.watch.add(res);
+        return res;
+    }
+    /**
+     * Enable reactivity of fields
+     */
+    enable() {
+        const $ = this.$;
+        if (!$.enabled) {
+            $.watch.forEach(watcher => {
+                watcher.$enable();
+            });
+            $.models.forEach(model => {
+                model.enableReactivity();
+            });
+            $.enabled = true;
+        }
+    }
+    /**
+     * Disable reactivity of fields
+     */
+    disable() {
+        const $ = this.$;
+        if ($.enabled) {
+            $.watch.forEach(watcher => {
+                watcher.$disable();
+            });
+            $.models.forEach(model => {
+                model.disableReactivity();
+            });
+            $.enabled = false;
+        }
+    }
+    /**
+     * Disable/Enable reactivity of object fields with feedback
+     * @param cond {IValue} show condition
+     * @param onOff {function} on show feedback
+     * @param onOn {function} on hide feedback
+     */
+    bindAlive(cond, onOff, onOn) {
+        const $ = this.$;
+        if ($.freezeExpr) {
+            throw (0, errors_1.wrongBinding)("this component already have a freeze state");
+        }
+        if ($.watch.has(cond)) {
+            throw (0, errors_1.wrongBinding)("freeze state must be bound to an external component");
+        }
+        $.freezeExpr = new expression_1.Expression((cond) => {
+            $.frozen = !cond;
+            if (cond) {
+                onOn === null || onOn === void 0 ? void 0 : onOn();
+                this.enable();
+            }
+            else {
+                onOff === null || onOff === void 0 ? void 0 : onOff();
+                this.disable();
+            }
+        }, true, cond);
+        return this;
+    }
+    init() {
+        this.applyOptions(this.input);
+        return this.compose(this.input);
+    }
+    applyOptions(input) {
+        // empty
+    }
+    applyOptionsNow() {
+        this.applyOptions(this.input);
+    }
+    compose(input) {
+        throw (0, errors_1.notOverwritten)();
+    }
+    composeNow() {
+        this.compose(this.input);
+    }
+    runFunctional(f, ...args) {
+        stack(this);
+        // yet another ts bug
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        const result = f(...args);
+        unstack();
+        return result;
+    }
+    runOnDestroy(func) {
+        this.$.onDestroy = func;
+    }
+    $destroy() {
+        super.$destroy();
+        this.$.$destroy();
+        this.$ = null;
+    }
+}
+exports.Reactive = Reactive;

package/lib-node/core/destroyable.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Destroyable = void 0;
+/**
+ * Mark an object which can be destroyed
+ * @class Destroyable
+ */
+class Destroyable {
+    /**
+     * Make object fields non configurable
+     * @protected
+     */
+    $seal() {
+        const $ = this;
+        Object.keys($).forEach(i => {
+            // eslint-disable-next-line no-prototype-builtins
+            if (this.hasOwnProperty(i)) {
+                const config = Object.getOwnPropertyDescriptor($, i);
+                if (config.configurable) {
+                    let descriptor;
+                    if (config.set || config.get) {
+                        descriptor = {
+                            configurable: false,
+                            get: config.get,
+                            set: config.set,
+                            enumerable: config.enumerable
+                        };
+                    }
+                    else {
+                        descriptor = {
+                            value: $[i],
+                            configurable: false,
+                            writable: config.writable,
+                            enumerable: config.enumerable
+                        };
+                    }
+                    Object.defineProperty($, i, descriptor);
+                }
+            }
+        });
+    }
+    /**
+     * Garbage collector method
+     */
+    $destroy() {
+        // nothing here
+    }
+}
+exports.Destroyable = Destroyable;

package/lib-node/core/errors.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrongBinding = exports.userError = exports.internalError = exports.notOverwritten = void 0;
+const reportIt = "Report it here: https://gitlab.com/vasille-js/vasille-js/-/issues";
+function notOverwritten() {
+    console.error("Vasille-SFP: Internal error", "Must be overwritten", reportIt);
+    return "not-overwritten";
+}
+exports.notOverwritten = notOverwritten;
+function internalError(msg) {
+    console.error("Vasille-SFP: Internal error", msg, reportIt);
+    return "internal-error";
+}
+exports.internalError = internalError;
+function userError(msg, err) {
+    console.error("Vasille-SFP: User error", msg);
+    return err;
+}
+exports.userError = userError;
+function wrongBinding(msg) {
+    return userError(msg, "wrong-binding");
+}
+exports.wrongBinding = wrongBinding;

package/lib-node/core/ivalue.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IValue = exports.Switchable = void 0;
+const destroyable_js_1 = require("./destroyable.js");
+const errors_1 = require("./errors");
+class Switchable extends destroyable_js_1.Destroyable {
+    /**
+     * Enable update handlers triggering
+     */
+    $enable() {
+        throw (0, errors_1.notOverwritten)();
+    }
+    /**
+     * disable update handlers triggering
+     */
+    $disable() {
+        throw (0, errors_1.notOverwritten)();
+    }
+}
+exports.Switchable = Switchable;
+/**
+ * Interface which describes a value
+ * @class IValue
+ * @extends Destroyable
+ */
+class IValue extends Switchable {
+    /**
+     * @param isEnabled {boolean} initial is enabled state
+     */
+    constructor(isEnabled) {
+        super();
+        this.isEnabled = isEnabled;
+    }
+    /**
+     * Get the encapsulated value
+     * @return {*} the encapsulated value
+     */
+    get $() {
+        throw (0, errors_1.notOverwritten)();
+    }
+    /**
+     * Sets the encapsulated value
+     * @param value {*} value to encapsulate
+     */
+    set $(value) {
+        throw (0, errors_1.notOverwritten)();
+    }
+    /**
+     * Add a new handler to value change
+     * @param handler {function(value : *)} the handler to add
+     */
+    $on(handler) {
+        throw (0, errors_1.notOverwritten)();
+    }
+    /**
+     * Removes a handler of value change
+     * @param handler {function(value : *)} the handler to remove
+     */
+    $off(handler) {
+        throw (0, errors_1.notOverwritten)();
+    }
+}
+exports.IValue = IValue;

package/lib-node/functional/options.js

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

package/lib-node/index.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.current = exports.userError = exports.Watch = exports.Reactive = exports.Binding = exports.Expression = exports.Portal = exports.App = exports.AppNode = exports.Extension = exports.Component = exports.Tag = exports.INode = exports.Fragment = exports.SetView = exports.ObjectView = exports.MapView = exports.ArrayView = exports.Listener = exports.BaseView = exports.SetModel = exports.ObjectModel = exports.MapModel = exports.ArrayModel = exports.Pointer = exports.Mirror = exports.Reference = exports.IValue = exports.Destroyable = void 0;
+const destroyable_1 = require("./core/destroyable");
+Object.defineProperty(exports, "Destroyable", { enumerable: true, get: function () { return destroyable_1.Destroyable; } });
+const core_1 = require("./core/core");
+Object.defineProperty(exports, "current", { enumerable: true, get: function () { return core_1.current; } });
+Object.defineProperty(exports, "Reactive", { enumerable: true, get: function () { return core_1.Reactive; } });
+const ivalue_1 = require("./core/ivalue");
+Object.defineProperty(exports, "IValue", { enumerable: true, get: function () { return ivalue_1.IValue; } });
+const array_model_1 = require("./models/array-model");
+Object.defineProperty(exports, "ArrayModel", { enumerable: true, get: function () { return array_model_1.ArrayModel; } });
+const listener_1 = require("./models/listener");
+Object.defineProperty(exports, "Listener", { enumerable: true, get: function () { return listener_1.Listener; } });
+const map_model_1 = require("./models/map-model");
+Object.defineProperty(exports, "MapModel", { enumerable: true, get: function () { return map_model_1.MapModel; } });
+const object_model_1 = require("./models/object-model");
+Object.defineProperty(exports, "ObjectModel", { enumerable: true, get: function () { return object_model_1.ObjectModel; } });
+const set_model_1 = require("./models/set-model");
+Object.defineProperty(exports, "SetModel", { enumerable: true, get: function () { return set_model_1.SetModel; } });
+const app_1 = require("./node/app");
+Object.defineProperty(exports, "App", { enumerable: true, get: function () { return app_1.App; } });
+Object.defineProperty(exports, "AppNode", { enumerable: true, get: function () { return app_1.AppNode; } });
+Object.defineProperty(exports, "Portal", { enumerable: true, get: function () { return app_1.Portal; } });
+const node_1 = require("./node/node");
+Object.defineProperty(exports, "Component", { enumerable: true, get: function () { return node_1.Component; } });
+Object.defineProperty(exports, "Extension", { enumerable: true, get: function () { return node_1.Extension; } });
+Object.defineProperty(exports, "Fragment", { enumerable: true, get: function () { return node_1.Fragment; } });
+Object.defineProperty(exports, "INode", { enumerable: true, get: function () { return node_1.INode; } });
+Object.defineProperty(exports, "Tag", { enumerable: true, get: function () { return node_1.Tag; } });
+const expression_1 = require("./value/expression");
+Object.defineProperty(exports, "Expression", { enumerable: true, get: function () { return expression_1.Expression; } });
+const mirror_1 = require("./value/mirror");
+Object.defineProperty(exports, "Mirror", { enumerable: true, get: function () { return mirror_1.Mirror; } });
+const pointer_1 = require("./value/pointer");
+Object.defineProperty(exports, "Pointer", { enumerable: true, get: function () { return pointer_1.Pointer; } });
+const reference_1 = require("./value/reference");
+Object.defineProperty(exports, "Reference", { enumerable: true, get: function () { return reference_1.Reference; } });
+const array_view_1 = require("./views/array-view");
+Object.defineProperty(exports, "ArrayView", { enumerable: true, get: function () { return array_view_1.ArrayView; } });
+const base_view_1 = require("./views/base-view");
+Object.defineProperty(exports, "BaseView", { enumerable: true, get: function () { return base_view_1.BaseView; } });
+const map_view_1 = require("./views/map-view");
+Object.defineProperty(exports, "MapView", { enumerable: true, get: function () { return map_view_1.MapView; } });
+const object_view_1 = require("./views/object-view");
+Object.defineProperty(exports, "ObjectView", { enumerable: true, get: function () { return object_view_1.ObjectView; } });
+const set_view_1 = require("./views/set-view");
+Object.defineProperty(exports, "SetView", { enumerable: true, get: function () { return set_view_1.SetView; } });
+const binding_1 = require("./binding/binding");
+Object.defineProperty(exports, "Binding", { enumerable: true, get: function () { return binding_1.Binding; } });
+const errors_1 = require("./core/errors");
+Object.defineProperty(exports, "userError", { enumerable: true, get: function () { return errors_1.userError; } });
+const watch_1 = require("./node/watch");
+Object.defineProperty(exports, "Watch", { enumerable: true, get: function () { return watch_1.Watch; } });

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;