@expressive/mvc 0.3.0 → 0.4.2

package/lib/index.d.ts

@@ -31,12 +31,12 @@ declare type Listener = {
 declare class Subscriber<T extends Stateful = any> {
     onUpdate: Controller.OnEvent;
     proxy: T;
+    commit: () => Callback;
     release: Callback;
-    commit: () => () => void;
     active: boolean;
     dependant: Set<Listener>;
-    watch: { [key in Model.Event<T, Model>]: boolean | Callback; };
-    constructor(target: Controller<T> | T, onUpdate: Controller.OnEvent);
+    add: (key: any, value?: Callback) => void;
+    constructor(parent: Controller<T>, onUpdate: Controller.OnEvent);
 }
 
 declare const CONTROL: unique symbol;
@@ -49,7 +49,7 @@ interface Stateful {
     /** Current subscriber (if present) while used in a live context (e.g. hook or effect). */
     [LOCAL]?: Subscriber;
     /** Current state of this instance. */
-    [STATE]?: this;
+    [STATE]?: Model.Values<this>;
     /**
      * Last update causing a refresh to subscribers.
      *
@@ -133,7 +133,7 @@ declare class Model {
     static [CONTROL]: Controller;
     static [WHY]: readonly string[];
     constructor();
-    get [STATE](): this;
+    get [STATE](): Model.Values<this, Exclude<keyof this & string, keyof Model>>;
     get [WHY](): readonly string[] | undefined;
     on<P = Model.Event<this>>(event: (key: P) => Callback | void): Callback;
     on<P = Model.Event<this>>(keys: [], listener: Model.OnUpdate<this, P>, squash?: boolean, once?: boolean): Callback;
@@ -149,7 +149,7 @@ declare class Model {
     once<P extends Model.Event<this>>(key: P | P[], listener: Model.OnUpdate<this, P>, squash?: false): Callback;
     once<P extends Model.Event<this>>(key: P | P[], listener: (keys: P[]) => void, squash: true): Callback;
     once<P extends Model.Event<this>>(key: P | P[], listener: unknown, squash: boolean): Callback;
-    once<P extends Model.Event<this>>(key: P | P[]): Promise<P[]>;
+    once<P extends Model.Event<this>>(key: P | P[], timeout?: number): Promise<void>;
     effect(callback: Model.Effect<this>): Callback;
     effect(callback: Model.Effect<this>, select: []): Callback;
     effect(callback: Model.Effect<this>, select: Model.Event<this>[]): Callback;
@@ -185,30 +185,22 @@ declare class Model {
 }
 
 declare namespace Controller {
-    type OnValue<T = any, S = Model.Values<T>> = (this: T, value: any, state: S) => boolean | void;
-    type OnEvent<T = any> = (key: Model.Event<T>, source: Controller) => Callback | void;
+    type OnValue<T = any> = (this: T, value: any) => boolean | void;
+    type OnEvent<T = any> = (key: Model.Event<T> | null, source: Controller) => Callback | void;
 }
 declare class Controller<T extends Stateful = any> {
     subject: T;
-    proxy: Model.Entries<T>;
-    state: Model.Values<T, Exclude<keyof T & string, keyof Model>>;
+    state: Map<any, any>;
     frame: Set<string>;
-    onDestroy: Set<Callback>;
-    private waiting;
-    protected followers: Set<Model.Controller.OnEvent<any>>;
+    waiting: Set<Callback>;
+    followers: Set<Model.Controller.OnEvent<any>>;
     constructor(subject: T);
-    start(): void;
-    stop(): void;
-    manage(key: Model.Field<T>, value: any): void;
-    ref(key: Model.Field<T>, handler?: Controller.OnValue<T>): (value: any) => void;
+    subscribe(callback: Controller.OnEvent<T>): Model.Subscriber<T>;
+    add(key: keyof T & string): void;
     addListener(listener: Controller.OnEvent<T>): () => void;
-    update(key: Model.Event<T>, value?: any): void;
-    flush(): void;
-    requestUpdate(): PromiseLike<readonly Model.Event<T>[] | false>;
-    requestUpdate(strict: true): Promise<readonly Model.Event<T>[]>;
-    requestUpdate(strict: false): Promise<false>;
-    requestUpdate(strict: boolean): Promise<readonly Model.Event<T>[] | false>;
-    requestUpdate(callback: Callback): void;
+    ref(key: Model.Field<T>, handler?: Controller.OnValue<T>): (value: any) => void;
+    update(key: Model.Field<T>): void;
+    clear(): void;
 }
 
 /**
@@ -217,8 +209,8 @@ declare class Controller<T extends Stateful = any> {
  */
 declare type Instruction<T> = (this: Controller, key: string, thisArg: Controller) => Instruction.Getter<T> | Instruction.ExplicitDescriptor | Instruction.Descriptor<T> | Instruction.RecursiveDescriptor<T> | boolean | void;
 declare namespace Instruction {
-    type Getter<T> = (state: T, within?: Subscriber) => T;
-    type Setter<T> = (value: T, state: any) => boolean | void;
+    type Getter<T> = (within?: Subscriber) => T;
+    type Setter<T> = (value: T) => boolean | void;
     type Runner<T> = (this: Controller, key: string, on: Controller) => Instruction.Descriptor<T> | boolean | undefined;
     interface Descriptor<T> {
         configurable?: boolean;
@@ -280,15 +272,6 @@ declare namespace ref {
         [P in Model.Field<T>]: Model.Ref<T[P]>;
     };
 }
-/**
- * Creates an object with references to all managed values.
- * Each property will set value in state when invoked.
- *
- * *Properties are simultaneously a ref-function and ref-object, use as needed.*
- *
- * @param target - Source model from which to reference values.
- */
-declare function ref<T extends Model>(target: T): ref.Proxy<T>;
 /**
  * Creates a ref-compatible property.
  * Will persist value, and updates to this are made part of controller event-stream.