@expressive/mvc 0.9.0 → 0.9.2

package/lib/index.d.ts

@@ -35,7 +35,6 @@ declare namespace Model {
     /** Including but not limited to T. */
     type Extends<T> = T | (string & Record<never, never>);
     export type Type<T extends Model = Model> = typeof Model & (new () => T);
-    export type OnUpdate<T, P> = (this: T, value: ValueOf<keyof T, P>, changed: P) => void;
     export type Effect<T> = (this: T, argument: T) => Callback | Promise<any> | void;
     /** Exotic value, actual value is contained. */
     export type Ref<T = any> = {
@@ -88,7 +87,8 @@ declare class Model {
     is: this;
     constructor();
     on<P extends Model.Event<this>>(key: P, timeout?: number): Promise<Model.ValueOf<this, P>>;
-    on<P extends Model.Event<this>>(key: P, listener: Model.OnUpdate<this, P>, once?: boolean): Callback;
+    on<P extends Model.Field<this>>(key: P, listener: (this: this, value: this[P], key: P) => void, once?: boolean): Callback;
+    on<P extends Model.Event<this>>(key: P, listener: (this: this, value: undefined, key: P) => void, once?: boolean): Callback;
     on<P extends Model.Event<this>>(keys: P[], timeout?: number): Promise<P[]>;
     on<P extends Model.Event<this>>(keys: P[], listener: (keys: P[]) => void, once?: boolean): Callback;
     on(effect: Model.Effect<this>): Callback;

package/lib/index.esm.js

@@ -73,8 +73,11 @@ function computeMode(self, source, setter, key, required) {
     const { subject, state } = self;
     let sub;
     let order = ORDER.get(self);
+    let pending = KEYS.get(self);
     if (!order)
-        ORDER.set(self, order = []);
+        ORDER.set(self, order = new Map());
+    if (!pending)
+        KEYS.set(self, pending = new Set());
     const compute = (initial) => {
         try {
             return setter.call(sub.proxy, sub.proxy);
@@ -100,18 +103,13 @@ function computeMode(self, source, setter, key, required) {
             }
         }
     };
-    const update = (_key, source) => {
-        if (source !== self) {
-            refresh();
-            return;
-        }
-        let pending = KEYS.get(self);
-        if (!pending)
-            KEYS.set(self, pending = []);
-        pending.push(refresh);
-    };
     const create = () => {
-        sub = source.subscribe(update);
+        sub = source.subscribe((_, source) => {
+            if (source !== self)
+                refresh();
+            else
+                pending.add(refresh);
+        });
         try {
             const value = compute(true);
             state.set(key, value);
@@ -122,11 +120,15 @@ function computeMode(self, source, setter, key, required) {
         }
         finally {
             sub.commit();
-            order.push(refresh);
+            order.set(refresh, order.size);
         }
     };
     INFO.set(refresh, key);
     return () => {
+        if (pending.has(refresh)) {
+            pending.delete(refresh);
+            refresh();
+        }
         const value = sub ? state.get(key) : create();
         if (value === undefined && required)
             throw suspend(self, key);
@@ -135,18 +137,20 @@ function computeMode(self, source, setter, key, required) {
 }
 function flush(control) {
     const pending = KEYS.get(control);
-    if (!pending)
+    if (!pending || !pending.size)
         return;
-    const list = ORDER.get(control);
-    while (pending.length) {
-        const compute = pending
-            .sort((a, b) => list.indexOf(b) - list.indexOf(a))
-            .pop();
+    const priority = ORDER.get(control);
+    while (pending.size) {
+        let compute;
+        for (const item of pending)
+            if (!compute || priority.get(item) < priority.get(compute))
+                compute = item;
+        pending.delete(compute);
         const key = INFO.get(compute);
         if (!control.frame.has(key))
             compute();
     }
-    KEYS.delete(control);
+    pending.clear();
 }
 
 const REGISTER$1 = new WeakMap();