@expressive/mvc 1.0.0-beta.24 → 1.0.0-beta.28

package/types/model.d.ts

@@ -113,9 +113,15 @@ export namespace Model {
 
     type HandleValue = (value: any) => boolean | void;
 
+    export namespace Controller {
+        export type Listen = (key: string, source: Controller) =>
+            RequestCallback | undefined;
+    }
+
     export class Controller {
         state: BunchOf<any>;
         subject: {};
+        waiting: Set<RequestCallback>;
 
         /** Add property to managed state. */
         manage(key: string, initial: any, effect?: HandleValue): void;
@@ -124,11 +130,9 @@ export namespace Model {
 
         setter(key: string, effect?: HandleValue): (value: any) => boolean | void;
 
-        addListener(batch: BunchOf<RequestCallback>): Callback;
+        addListener(listener: Controller.Listen): Callback;
 
         update(key: string, value?: any): void;
-
-        include(cb: RequestCallback): void;
     }
 
     export class Subscriber {
@@ -136,13 +140,13 @@ export namespace Model {
         source: any;
         parent: Controller;
         active: boolean;
-        follows: BunchOf<Callback>;
+        listen: Controller.Listen;
         dependant: Set<{
             commit(): void;
             release(): void;
         }>;
 
-        follow(key: string, cb?: Callback | undefined): void;
+        follow(key: string, cb?: RequestCallback | undefined): void;
         commit(): Callback;
         release(): Callback;
         onUpdate(): void;
@@ -150,6 +154,7 @@ export namespace Model {
 }
 
 declare const CONTROL: unique symbol;
+declare const UPDATE: unique symbol;
 declare const LOCAL: unique symbol;
 declare const STATE: unique symbol;
 
@@ -164,6 +169,14 @@ export abstract class Model {
     /** Current subscriber (if present) while used in a live context (e.g. hook or effect). */
     [LOCAL]?: Model.Subscriber;
 
+    /**
+     * Last update causing a refresh to subscribers.
+     * 
+     * If accessed directly, will contain all keys from last push.
+     * If within a subscribed function, will contain only keys which explicitly caused a refresh.
+     **/
+    [UPDATE]?: readonly string[];
+
     /**
      * Circular reference to `this` controller.
      * 
@@ -229,19 +242,19 @@ export abstract class Model {
     export <P extends Model.Fields<this>> (select: P[]): Model.State<this, P>;
     export <S extends Model.SelectFields<this>> (select: S): Model.State<this, Selector.From<S>>;
 
-    update(): PromiseLike<string[] | false>;
-    update(strict: true): Promise<string[]>;
+    update(): PromiseLike<readonly string[] | false>;
+    update(strict: true): Promise<readonly string[]>;
     update(strict: false): Promise<false>;
-    update(strict: boolean): Promise<string[] | false>;
+    update(strict: boolean): Promise<readonly string[] | false>;
 
-    update(keys: Model.Fields<this>): Thenable<string[]>;
-    update(keys: Model.SelectFieldKey<this>): Thenable<string[]>;
+    update(keys: Model.Fields<this>): Thenable<readonly string[]>;
+    update(keys: Model.SelectFieldKey<this>): Thenable<readonly string[]>;
 
-    update(keys: Model.Fields<this>, callMethod: boolean): PromiseLike<string[]>;
-    update(keys: Model.SelectFields<this>, callMethod: boolean): PromiseLike<string[]>;
+    update(keys: Model.Fields<this>, callMethod: boolean): PromiseLike<readonly string[]>;
+    update(keys: Model.SelectFields<this>, callMethod: boolean): PromiseLike<readonly string[]>;
 
-    update<T>(keys: Model.Fields<this>, argument: T): PromiseLike<string[]>;
-    update<T>(keys: Model.SelectFields<this>, argument: T): PromiseLike<string[]>;
+    update<T>(keys: Model.Fields<this>, argument: T): PromiseLike<readonly string[]>;
+    update<T>(keys: Model.SelectFields<this>, argument: T): PromiseLike<readonly string[]>;
 
     /*
     Issue with self-reference, using fallback.
@@ -284,28 +297,36 @@ export abstract class Model {
     
     // Keyed
     on <S extends Model.SelectEvents<this>> (via: S, cb: Selector.Callback<S, this>, squash?: false, once?: boolean): Callback;
+    on <P = Model.EventsCompat<this>> (keys: [], listener: UpdateCallback<this, P>, squash?: false, once?: boolean): Callback;
     on <P extends Model.EventsCompat<this>> (key: P | P[], listener: UpdateCallback<this, P>, squash?: false, once?: boolean): Callback;
     // Squash
     on <S extends Model.SelectEvents<this>> (via: S, cb: (keys: Selector.From<S>[]) => void, squash: true, once?: boolean): Callback;
+    on <P = Model.EventsCompat<this>> (keys: [], listener: (keys: P[]) => void, squash: true, once?: boolean): Callback;
     on <P extends Model.EventsCompat<this>> (key: P | P[], listener: (keys: P[]) => void, squash: true, once?: boolean): Callback;
     // Unknown
     on <S extends Model.SelectEvents<this>> (via: S, cb: unknown, squash: boolean, once?: boolean): Callback;
+    on (keys: [], listener: unknown, squash: boolean, once?: boolean): Callback;
     on <P extends Model.EventsCompat<this>> (key: P | P[], listener: unknown, squash: boolean, once?: boolean): Callback;
 
     // Keyed
     once <S extends Model.SelectEvents<this>> (via: S, cb: Selector.Callback<S, this>, squash?: false): Callback;
+    once <P = Model.EventsCompat<this>> (keys: [], listener: UpdateCallback<this, P>, squash?: false, once?: boolean): Callback;
     once <P extends Model.EventsCompat<this>> (key: P | P[], listener: UpdateCallback<this, P>, squash?: false): Callback;
     // Squash
     once <S extends Model.SelectEvents<this>> (via: S, cb: (keys: Selector.From<S>[]) => void, squash: true): Callback;
+    once <P = Model.EventsCompat<this>> (keys: [], listener: (keys: P[]) => void, squash: true, once?: boolean): Callback;
     once <P extends Model.EventsCompat<this>> (key: P | P[], listener: (keys: P[]) => void, squash: true): Callback;
     // Promise
     once <S extends Model.SelectEvents<this>> (via: S): Promise<Selector.From<S>[]>;
+    once <P = Model.EventsCompat<this>> (keys: [], listener: (keys: P[]) => void, squash: true, once?: boolean): Callback;
     once <P extends Model.EventsCompat<this>> (key: P | P[]): Promise<P[]>;
     // Unknown
     once <S extends Model.SelectEvents<this>> (via: S, cb: unknown, squash: boolean): Callback;
+    once (keys: [], listener: unknown, squash: boolean, once?: boolean): Callback;
     once <P extends Model.EventsCompat<this>> (key: P | P[], listener: unknown, squash: boolean): Callback;
 
     effect(callback: (this: this, state: this) => void, select?: Model.SelectFields<this>): Callback;
+    effect(callback: (this: this, state: this) => void, select?: []): Callback;
     effect(callback: (this: this, state: this) => void, select?: (keyof this)[]): Callback;
 
     /**
@@ -344,6 +365,9 @@ export abstract class Model {
     /** Use symbol to access current subscriber of a model in a live context (e.g. hook or effect). */
     static LOCAL: typeof LOCAL;
 
+    /** Use symbol to access keys affected by last update. */
+    static WHY: typeof UPDATE;
+
     /**
      * Creates a new instance of this controller.
      * 

package/types/types.d.ts

@@ -7,7 +7,7 @@ export type InstanceOf<T> = T extends { prototype: infer U } ? U : never;
 export type IfApplicable<T extends {}, K> = K extends keyof T ? T[K] : undefined;
 
 export type Callback = () => void;
-export type RequestCallback = (keys?: string[]) => void;
+export type RequestCallback = (keys: readonly string[]) => void;
 export type EffectCallback<T, A = T> = (this: T, argument: A) => Callback | Promise<any> | void;
 export type UpdateCallback<T, P> = (this: T, value: IfApplicable<T, P>, changed: P) => void;
 export type InterceptCallback<T, S = any> = (this: S, argument: T) => ((next: T) => void) | Promise<any> | void | boolean;