@expressive/mvc 0.8.2 → 0.9.1

package/lib/index.d.ts

@@ -8,18 +8,21 @@ declare type Listener = {
     commit(): void;
     release(): void;
 };
+declare namespace Subscriber {
+    type OnEvent<T = any> = (key: Model.Event<T> | null, source: Control) => Callback | void;
+}
 declare class Subscriber<T extends {} = any> {
     parent: Control<T>;
-    onUpdate: Control.OnEvent;
-    static get<T extends {}>(from: T): Model.Subscriber<T> | undefined;
+    onUpdate: Subscriber.OnEvent;
+    static get<T extends {}>(from: T): Subscriber<T> | undefined;
     proxy: T;
     release: Callback;
     latest?: Model.Event<T>[];
     active: boolean;
     dependant: Set<Listener>;
     watch: Map<any, boolean | (() => true | void)>;
-    constructor(parent: Control<T>, onUpdate: Control.OnEvent);
-    get using(): Model.Values<T>;
+    constructor(parent: Control<T>, onUpdate: Subscriber.OnEvent);
+    get using(): Model.Values<T>[];
     assign(apply: Model.Compat<T>, keys?: any): void;
     add(key: any, value?: boolean | Callback): void;
     commit: () => () => void;
@@ -84,33 +87,28 @@ declare class Model {
      */
     is: this;
     constructor();
-    on<P = Model.Event<this>>(event: (key: P) => Callback | void): Callback;
-    on<P extends Model.Event<this>>(key: P): Promise<Model.ValueOf<this, P>>;
-    on<P extends Model.Event<this>>(key: P, timeout: number): Promise<Model.ValueOf<this, P>>;
+    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.Event<this>>(key: P[]): Promise<P[]>;
-    on<P extends Model.Event<this>>(key: P[], timeout: number): Promise<P[]>;
-    on<P extends Model.Event<this>>(key: P[], listener: (keys: P[]) => void, once?: boolean): Callback;
-    on<P = Model.Event<this>>(keys: [], listener: Model.OnUpdate<this, P>, once?: boolean): Callback;
-    on<P = Model.Event<this>>(keys: [], listener: (keys: P[]) => void, once?: boolean): Callback;
-    effect(callback: Model.Effect<this>): Callback;
-    effect(callback: Model.Effect<this>, select: []): Callback;
-    effect(callback: Model.Effect<this>, select: Model.Event<this>[]): 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;
+    on(effect: Model.Effect<this>, watch?: []): Callback;
+    on(effect: Model.Effect<this>, watch?: Model.Event<this>[]): Callback;
+    on(key?: undefined, timeout?: number): Promise<Model.Event<this>[]>;
+    on(current?: boolean): Promise<Model.Event<this>[] | null>;
+    on(current: true): Promise<Model.Event<this>[]>;
+    on(current: null): Promise<null>;
     export(): Model.Values<this>;
-    export<P extends Model.Field<this>>(select: P[]): Model.Values<this, P>;
-    update(): PromiseLike<readonly Model.Event<this>[] | false>;
-    update(strict: true): Promise<readonly Model.Event<this>[]>;
-    update(strict: false): Promise<false>;
-    update(strict: boolean): Promise<readonly Model.Event<this>[] | false>;
+    export<P extends Model.Field<this>>(select: Iterable<P>): Model.Values<this, P>;
     update(key: Model.Event<this>): PromiseLike<readonly Model.Event<this>[]>;
     update(key: Model.Event<this>, callMethod: boolean): PromiseLike<readonly Model.Event<this>[]>;
     update<T>(key: Model.Event<this>, argument: T): PromiseLike<readonly Model.Event<this>[]>;
     update<T extends Model.Compat<this>>(source: T, select: (keyof T)[]): PromiseLike<(keyof T)[]>;
     update<T extends Model.Compat<this>>(source: T, force?: boolean): PromiseLike<(keyof T)[]>;
     /**
-     * Mark this instance for garbage-collection and send `willDestroy` event to all listeners.
+     * Clean up side effects and mark this instance for garbage-collection.
      */
-    kill(): void;
+    destroy(): void;
     /**
      * Creates a new instance of this controller.
      *
@@ -128,22 +126,32 @@ declare class Model {
 }
 
 declare namespace Control {
-    type OnValue<T = any> = (this: T, value: any) => boolean | void;
-    type OnEvent<T = any> = (key: Model.Event<T> | null, source: Control) => Callback | void;
+    /**
+     * Callback for Controller.for() static method.
+     * Returned callback is forwarded.
+     */
     type OnReady<T extends {}> = (control: Control<T>) => Callback | void;
+    /**
+     * Called immediately when any key is changed or emitted.
+     * Returned callback is notified when update is complete.
+     */
+    type OnSync<T = any> = (key: Model.Event<T> | null, source: Control) => OnAsync<T> | void;
+    /** Called at the end of an event frame with all keys affected. */
+    type OnAsync<T = any> = (keys: Model.Event<T>[]) => void;
+    type OnValue<T = any> = (this: T, value: any) => boolean | void;
 }
 declare class Control<T extends {} = any> {
     subject: T;
     state: Map<any, any>;
     frame: Set<string>;
-    waiting: Set<Callback>;
-    followers: Set<Model.Control.OnEvent<any>>;
+    waiting: Set<Model.Control.OnAsync<T>>;
+    followers: Set<Model.Control.OnSync<any>>;
     latest?: Model.Event<T>[];
     constructor(subject: T);
-    subscribe(callback: Control.OnEvent<T>): Model.Subscriber<T>;
+    subscribe(callback: Subscriber.OnEvent<T>): Model.Subscriber<T>;
     watch(key: keyof T & string): void;
-    addListener(listener: Control.OnEvent<T>): () => void;
-    ref(key: Model.Field<T>, handler?: Control.OnValue<T>): (value: any) => void;
+    addListener(listener: Control.OnSync<T>): () => void;
+    ref<K extends Model.Field<T>>(key: K, handler?: (this: T, value: T[K]) => boolean | void): (value: any) => void;
     update(key: Model.Field<T>): void;
     clear(): void;
     static get<T extends {}>(from: T): Control<T> | undefined;
@@ -191,17 +199,17 @@ declare type Async<T = any> = (...args: any[]) => Promise<T>;
 /**
  * Sets an exotic method with managed ready-state. Property accepts an async function.
  *
- * When an act-method is invoked, its `active` property to true for duration of call.
+ * When a run-method is invoked, its `active` property to true for duration of call.
  * This is emitted as an update to property, both when called and after returns (or throws).
  *
  * **Note:** Subsequent calls will immediately throw if one is still pending.
  *
  * @param action - Action to fire when resulting property is invoked.
  */
-declare function act(action: Async): typeof action & {
+declare function run(action: Async): typeof action & {
     active: boolean;
 };
-declare function act<S>(action: Async<S>): typeof action & {
+declare function run<S>(action: Async<S>): typeof action & {
     active: boolean;
 };
 
@@ -522,7 +530,7 @@ declare function Provider<T extends Provider.Item>(props: Provider.Props<T>): Re
 
 declare class Global extends MVC {
     constructor();
-    kill(force?: boolean): boolean;
+    destroy(force?: boolean): boolean;
     static keepAlive: boolean;
     static new<T extends Class>(this: T, ...args: ConstructorParameters<T>): InstanceOf<T>;
     /**
@@ -576,8 +584,8 @@ declare function tap<T extends Model>(Type: Model.Type<T>, callback?: (instance?
 declare function tap<T extends Model>(Type: Model.Type<T>, required: true): T;
 declare function tap<T extends Model>(Type: Model.Type<T>, required?: boolean): T | undefined;
 
-declare function useFrom<T extends {}, R>(source: (() => T) | T, compute: (this: T, from: T) => R, expect: true): Exclude<R, undefined>;
-declare function useFrom<T extends {}, R>(source: (() => T) | T, compute: (this: T, from: T) => R, expect?: boolean): R;
+declare function useValue<T extends {}, R>(source: (() => T) | T, compute: (this: T, from: T) => R, expect: true): Exclude<R, undefined>;
+declare function useValue<T extends {}, R>(source: (() => T) | T, compute: (this: T, from: T) => R, expect?: boolean): R;
 
 declare function useModel<T extends Model>(source: Model.Type<T> | (() => T), callback?: (instance: T) => void): T;
 declare function useModel<T extends Model>(source: Model.Type<T> | (() => T), watch: Model.Field<T>[], callback?: (instance: T) => void): T;
@@ -592,4 +600,4 @@ declare function useTap<T extends Model, K extends Model.Field<T>>(source: useTa
 declare function useTap<T extends Model, R>(source: useTap.Source<T>, compute: (this: T, from: T) => R, expect: true): Exclude<R, undefined>;
 declare function useTap<T extends Model, R>(source: useTap.Source<T>, compute: (this: T, from: T) => R, expect?: boolean): R;
 
-export { Consumer, Debug, Global, MVC, MVC as Model, Provider, act, add, MVC as default, get, has, ref, set, tap, use, useContext, useFrom, useModel, useTap };
+export { Consumer, Debug, Global, MVC, MVC as Model, Provider, add, MVC as default, get, has, ref, run, set, tap, use, useContext, useModel, useTap, useValue };