vasille 2.0.3 → 2.2.0

package/lib/functional/stack.js

@@ -0,0 +1,127 @@
+import { Component, Extension, Fragment } from "../node/node";
+import { App } from "../node/app";
+import { current } from "../core/core";
+import { ArrayModel } from "../models/array-model";
+import { ArrayView } from "../views/array-view";
+import { MapModel } from "../models/map-model";
+import { MapView } from "../views/map-view";
+import { SetModel } from "../models/set-model";
+import { SetView } from "../views/set-view";
+import { ObjectModel } from "../models/object-model";
+import { ObjectView } from "../views/object-view";
+import { Watch } from "../node/watch";
+import { userError } from "../core/errors";
+export function app(renderer) {
+    return (node, opts) => {
+        return new App(node, opts).runFunctional(renderer, opts);
+    };
+}
+export function component(renderer) {
+    return (opts, callback) => {
+        const component = new Component(opts);
+        if (!(current instanceof Fragment))
+            throw userError('missing parent node', 'out-of-context');
+        let ret;
+        if (callback)
+            opts.slot = callback;
+        current.create(component, node => {
+            ret = node.runFunctional(renderer, opts);
+        });
+        return ret;
+    };
+}
+export function fragment(renderer) {
+    return (opts, callback) => {
+        const frag = new Fragment(opts);
+        if (!(current instanceof Fragment))
+            throw userError('missing parent node', 'out-of-context');
+        if (callback)
+            opts.slot = callback;
+        current.create(frag);
+        return frag.runFunctional(renderer, opts);
+    };
+}
+export function extension(renderer) {
+    return (opts, callback) => {
+        const ext = new Extension(opts);
+        if (!(current instanceof Fragment))
+            throw userError('missing parent node', 'out-of-context');
+        if (callback)
+            opts.slot = callback;
+        current.create(ext);
+        return ext.runFunctional(renderer, opts);
+    };
+}
+export function tag(name, opts, callback) {
+    if (!(current instanceof Fragment))
+        throw userError('missing parent node', 'out-of-context');
+    return {
+        node: current.tag(name, opts, (node) => {
+            callback && node.runFunctional(callback);
+        })
+    };
+}
+export function create(node, callback) {
+    if (!(current instanceof Fragment))
+        throw userError('missing current node', 'out-of-context');
+    current.create(node, (node, ...args) => {
+        callback && node.runFunctional(callback, ...args);
+    });
+    return node;
+}
+export const vx = {
+    if(condition, callback) {
+        if (current instanceof Fragment) {
+            current.if(condition, node => node.runFunctional(callback));
+        }
+        else {
+            throw userError("wrong use of `v.if` function", "logic-error");
+        }
+    },
+    else(callback) {
+        if (current instanceof Fragment) {
+            current.else(node => node.runFunctional(callback));
+        }
+        else {
+            throw userError("wrong use of `v.else` function", "logic-error");
+        }
+    },
+    elif(condition, callback) {
+        if (current instanceof Fragment) {
+            current.elif(condition, node => node.runFunctional(callback));
+        }
+        else {
+            throw userError("wrong use of `v.elif` function", "logic-error");
+        }
+    },
+    for(model, callback) {
+        if (model instanceof ArrayModel) {
+            // for arrays T & K are the same type
+            create(new ArrayView({ model }), callback);
+        }
+        else if (model instanceof MapModel) {
+            create(new MapView({ model }), callback);
+        }
+        else if (model instanceof SetModel) {
+            // for sets T & K are the same type
+            create(new SetView({ model }), callback);
+        }
+        else if (model instanceof ObjectModel) {
+            // for objects K is always string
+            create(new ObjectView({ model }), callback);
+        }
+        else {
+            throw userError("wrong use of `v.for` function", 'wrong-model');
+        }
+    },
+    watch(model, callback) {
+        const opts = { model };
+        create(new Watch(opts), callback);
+    },
+    nextTick(callback) {
+        const node = current;
+        window.setTimeout(() => {
+            node.runFunctional(callback);
+        }, 0);
+    }
+};

package/lib/index.js

@@ -1,16 +1,12 @@
 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";
@@ -20,8 +16,7 @@ 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, };
+import * as libV from "./v/index";
+export { Destroyable, IValue, Reference, Mirror, Pointer, ArrayModel, MapModel, ObjectModel, SetModel, BaseView, Listener, ArrayView, MapView, ObjectView, SetView, Fragment, INode, Tag, Component, Extension, AppNode, App, Expression, Binding, Reactive, libV };

package/lib/models/array-model.js

@@ -19,6 +19,15 @@ export class ArrayModel extends Array {
             super.push(data[i]);
         }
     }
+    // proxy
+    proxy() {
+        return new Proxy(this, {
+            set(target, p, value) {
+                target.splice(parseInt(p), 1, value);
+                return true;
+            }
+        });
+    }
     /* Array members */
     /**
      * Gets the last item of array

package/lib/models/object-model.js

@@ -10,13 +10,14 @@ export class ObjectModel extends Object {
      */
     constructor(obj = {}) {
         super();
+        this.container = Object.create(null);
         Object.defineProperty(this, 'listener', {
             value: new Listener,
             writable: false,
             configurable: false
         });
         for (const i in obj) {
-            Object.defineProperty(this, i, {
+            Object.defineProperty(this.container, i, {
                 value: obj[i],
                 configurable: true,
                 writable: true,
@@ -31,8 +32,7 @@ export class ObjectModel extends Object {
      * @return {*}
      */
     get(key) {
-        const ts = this;
-        return ts[key];
+        return this.container[key];
     }
     /**
      * Sets an object property value
@@ -41,21 +41,19 @@ export class ObjectModel extends Object {
      * @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;
+        if (Reflect.has(this.container, key)) {
+            this.listener.emitRemoved(key, this.container[key]);
+            this.container[key] = v;
         }
         else {
-            Object.defineProperty(ts, key, {
+            Object.defineProperty(this.container, key, {
                 value: v,
                 configurable: true,
                 writable: true,
                 enumerable: true
             });
         }
-        this.listener.emitAdded(key, ts[key]);
+        this.listener.emitAdded(key, this.container[key]);
         return this;
     }
     /**
@@ -63,12 +61,28 @@ export class ObjectModel extends Object {
      * @param key {string} property name
      */
     delete(key) {
-        const ts = this;
-        if (ts[key]) {
-            this.listener.emitRemoved(key, ts[key]);
-            delete ts[key];
+        if (this.container[key]) {
+            this.listener.emitRemoved(key, this.container[key]);
+            delete this.container[key];
         }
     }
+    proxy() {
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        const ts = this;
+        return new Proxy(this.container, {
+            get(target, p) {
+                return ts.get(p);
+            },
+            set(target, p, value) {
+                ts.set(p, value);
+                return true;
+            },
+            deleteProperty(target, p) {
+                ts.delete(p);
+                return true;
+            }
+        });
+    }
     enableReactivity() {
         this.listener.enableReactivity();
     }

package/lib/node/app.js

@@ -1,4 +1,3 @@
-import { instantExecutor, timeoutExecutor } from "../core/executor";
 import { INode } from "./node";
 /**
  * Application Node
@@ -7,12 +6,12 @@ import { INode } from "./node";
  */
 export class AppNode extends INode {
     /**
-     * @param options {Object} Application options
+     * @param input
      */
-    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;
+    constructor(input) {
+        super(input);
+        this.debugUi = input.debugUi || false;
+        this.seal();
     }
 }
 /**
@@ -24,16 +23,26 @@ export class App extends AppNode {
     /**
      * Constructs an app node
      * @param node {Element} The root of application
-     * @param options {Object} Application options
+     * @param input
      */
-    constructor(node, options) {
-        super(options);
+    constructor(node, input) {
+        super(input);
         this.$.node = node;
-        this.$preinit(this, this);
-        this.$seal();
+        this.preinit(this, this);
+        this.init();
+        this.seal();
     }
-    $$appendNode(node) {
-        const $ = this.$;
-        $.app.$run.appendChild($.node, node);
+    appendNode(node) {
+        this.$.node.appendChild(node);
+    }
+}
+export class Portal extends AppNode {
+    constructor(input) {
+        super(input);
+        this.$.node = input.node;
+        this.seal();
+    }
+    appendNode(node) {
+        this.$.node.appendChild(node);
     }
 }

package/lib/node/interceptor.js

@@ -49,8 +49,8 @@ export class Interceptor extends Destroyable {
             signal.unsubscribe(handler);
         });
     }
-    $destroy() {
-        super.$destroy();
+    destroy() {
+        super.destroy();
         this.signals.forEach(signal => {
             this.handlers.forEach(handler => {
                 signal.unsubscribe(handler);
@@ -77,7 +77,7 @@ export class InterceptorNode extends Fragment {
          */
         this.slot = new Slot;
     }
-    $compose() {
+    compose() {
         this.slot.release(this, this.interceptor);
     }
 }