@expressive/mvc 0.0.4 → 0.1.0

package/lib/index.d.ts

@@ -75,6 +75,11 @@ declare namespace Model {
     export type Methods<T> = {
         [K in keyof T]: T[K] extends Ref ? never : T[K] extends Function ? K : never;
     }[keyof T];
+    export type Refs<T extends Model> = {
+        <K extends Field<T>>(key: K, value: T[K]): void;
+    } & {
+        [P in Field<T>]: (next: any) => void;
+    };
     /**
      * Subset of `keyof T` which are not methods or defined by base Model U.
      *
@@ -110,11 +115,12 @@ interface Model extends Stateful {
      */
     get: this;
     /**
-    * Circular reference to `this` controller.
+    * Setter utility
     *
-    * Shortcut is mainly to update values, while having destructured already.
+    * Can be used to set (and force-update) values.
+    * Shortcut to update values, contains refs for all controlled values.
     */
-    set: this;
+    set: Model.Refs<this>;
 }
 declare class Model {
     static [CONTROL]: Controller;
@@ -186,7 +192,7 @@ declare class Controller<T extends Stateful = any> {
     constructor(subject: T);
     start(): void;
     stop(): void;
-    private manage;
+    manage(key: Model.Field<T>, value: any): void;
     ref(key: Model.Field<T>, handler?: Controller.OnValue<T>): (value: any) => void;
     addListener(listener: Controller.OnEvent<T>): () => void;
     emit(keys: readonly Model.Event<T>[]): void;

package/lib/index.esm.js

@@ -148,9 +148,18 @@ const LOCAL = Symbol("LOCAL");
 const STATE = Symbol("STATE");
 class Model {
     constructor() {
-        define(this, CONTROL, new Controller(this));
+        const control = new Controller(this);
+        define(this, CONTROL, control);
         define(this, "get", this);
-        define(this, "set", this);
+        defineLazy(this, "set", () => {
+            const assign = (key, value) => {
+                control.update(key, value);
+            };
+            ready(control);
+            for (const key of getOwnPropertyNames(control.proxy))
+                define(assign, key, control.ref(key));
+            return assign;
+        });
     }
     get [STATE]() {
         return this[CONTROL].state;
@@ -287,10 +296,7 @@ class Model {
         return (typeof maybe == "function" &&
             maybe.prototype instanceof this);
     }
-}
-defineLazy(Model, CONTROL, function () {
-    return new Controller(this);
-});
+}
 
 class Subscriber {
     constructor(target, onUpdate) {
@@ -492,26 +498,28 @@ class Controller {
         this.proxy = Object.create(subject);
     }
     start() {
-        for (const key in this.subject)
-            this.manage(key);
+        READY.add(this);
+        for (const key in this.subject) {
+            const { value: entry } = getOwnPropertyDescriptor(this.subject, key);
+            if (typeof entry == "function")
+                continue;
+            if (typeof entry == "symbol") {
+                const instruction = PENDING.get(entry);
+                if (instruction)
+                    instruction.call(this, key, this);
+                continue;
+            }
+            this.manage(key, entry);
+        }
         this.emit([]);
     }
     stop() {
         this.followers.clear();
         this.onDestroy.forEach(x => x());
     }
-    manage(key) {
+    manage(key, value) {
         const { proxy, state, subject } = this;
-        const { value: entry } = getOwnPropertyDescriptor(subject, key);
-        if (typeof entry == "function")
-            return;
-        if (typeof entry == "symbol") {
-            const instruction = PENDING.get(entry);
-            if (instruction)
-                instruction.call(this, key, this);
-            return;
-        }
-        state[key] = entry;
+        state[key] = value;
         const set = this.ref(key);
         defineProperty(subject, key, {
             enumerable: false,
@@ -603,26 +611,23 @@ class Controller {
 }
 function control(subject, cb) {
     let control = subject[CONTROL];
-    const ready = READY.has(control);
     if (!control) {
         control = new Controller(subject);
         define(subject, CONTROL, control);
     }
-    if (!cb) {
-        if (!ready) {
-            READY.add(control);
-            control.start();
-        }
-        return control;
-    }
+    return ready(control, cb);
+}
+function ready(control, cb) {
+    const ready = READY.has(control);
     if (!ready) {
-        let done;
-        control.requestUpdate(() => {
-            done = cb(control);
-        });
-        return () => done && done();
+        if (cb) {
+            let done;
+            control.requestUpdate(() => done = cb(control));
+            return () => done && done();
+        }
+        control.start();
     }
-    return cb(control);
+    return cb ? cb(control) : control;
 }
 
 function apply(fn, label) {