@expressive/mvc 0.2.5 → 0.4.0

package/lib/index.d.ts

@@ -23,7 +23,6 @@ declare function array<T = any>(): T[];
 type Callback = () => void;
 type Class = new (...args: any[]) => any;
 type InstanceOf<T> = T extends { prototype: infer U } ? U : never;
-type RequestCallback<T extends string = string> = (keys: readonly T[]) => void;
 
 declare type Listener = {
     commit(): void;
@@ -32,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;
@@ -50,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.
      *
@@ -134,9 +133,9 @@ 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) => RequestCallback | void): Callback;
+    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;
     on<P = Model.Event<this>>(keys: [], listener: (keys: P[]) => void, squash: true, once?: boolean): Callback;
     on(keys: [], listener: unknown, squash: boolean, once?: boolean): Callback;
@@ -150,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;
@@ -186,30 +185,22 @@ declare class Model {
 }
 
 declare namespace Controller {
-    type OnEvent<T = any> = (key: Model.Event<T>, source: Controller) => RequestCallback | void;
-    type OnValue<T = any, S = Model.Values<T>> = (this: T, value: any, state: S) => boolean | 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>;
-    waiting: Set<RequestCallback<string>>;
-    onDestroy: Set<Callback>;
-    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;
-    emit(keys: readonly Model.Event<T>[]): void;
-    update(key: Model.Event<T>, value?: any): 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: (keys: readonly Model.Event<T>[]) => void): void;
+    ref(key: Model.Field<T>, handler?: Controller.OnValue<T>): (value: any) => void;
+    update(key: Model.Field<T>): void;
+    clear(): void;
 }
 
 /**
@@ -218,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;
@@ -281,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.
@@ -301,30 +283,10 @@ declare function ref<T extends Model>(target: T): ref.Proxy<T>;
 declare function ref<T = HTMLElement>(callback?: ref.Callback<T>): ref.Object<T>;
 declare function ref<T, S>(callback?: ref.Callback<T, S>): ref.Object<T>;
 
-declare namespace set {
+declare namespace set$1 {
     type Factory<T, S = unknown> = (this: S, key: string, subject: S) => T;
     type Callback<T, S = any> = (this: S, argument: T) => ((next: T) => void) | Promise<any> | void | boolean;
 }
-/**
- * Set property with a placeholder.
- *
- * Property cannot be accessed until it is defined. If accessed while undefined, a hybrid
- * `Promise`/`Error` (ala: [Suspense](https://reactjs.org/docs/concurrent-mode-suspense.html)) will be thrown.
- */
-declare function set<T = any>(): T;
-/**
- * Set property with starting value `undefined`.
- *
- * If required and accessed while still empty, React Suspense will be thrown.
- * Property will reject any assignment of undefined.
- *
- * @param value - Starting value of host property (undefined).
- * @param required - Property will suspend callee if undefined at time of access.
- */
-declare function set<T>(value: undefined, required: false): T | undefined;
-declare function set<T>(value: undefined, required?: boolean): T;
-declare function set<T>(value: undefined, onUpdate: set.Callback<T>): T | undefined;
-declare function set<T, S>(value: undefined, onUpdate: set.Callback<T, S>): T | undefined;
 /**
  * Set property with an async function.
  *
@@ -340,12 +302,12 @@ declare function set<T, S>(value: undefined, onUpdate: set.Callback<T, S>): T |
  * @param factory - Callback run to derrive property value.
  * @param required - (default: true) Run factory immediately on creation, otherwise on access.
  */
-declare function set<T>(factory: set.Factory<Promise<T>>, required: false): T | undefined;
-declare function set<T, S>(factory: set.Factory<Promise<T>, S>, required: false): T | undefined;
-declare function set<T>(factory: set.Factory<Promise<T>>, required?: boolean): T;
-declare function set<T, S>(factory: set.Factory<Promise<T>, S>, required?: boolean): T;
-declare function set<T>(value: set.Factory<Promise<T>>, onUpdate: set.Callback<T>): T;
-declare function set<T, S>(value: set.Factory<Promise<T>, S>, onUpdate: set.Callback<T, S>): T;
+declare function put<T>(factory: set$1.Factory<Promise<T>>, required: false): T | undefined;
+declare function put<T, S>(factory: set$1.Factory<Promise<T>, S>, required: false): T | undefined;
+declare function put<T>(factory: set$1.Factory<Promise<T>>, required?: boolean): T;
+declare function put<T, S>(factory: set$1.Factory<Promise<T>, S>, required?: boolean): T;
+declare function put<T>(value: set$1.Factory<Promise<T>>, onUpdate: set$1.Callback<T>): T;
+declare function put<T, S>(value: set$1.Factory<Promise<T>, S>, onUpdate: set$1.Callback<T, S>): T;
 /**
  * Set property with a factory function.
  *
@@ -358,24 +320,41 @@ declare function set<T, S>(value: set.Factory<Promise<T>, S>, onUpdate: set.Call
  * @param factory - Callback run to derrive property value.
  * @param required - (default: true) Run factory immediately on creation, otherwise on access.
  */
-declare function set<T>(factory: set.Factory<T>, required: false): T | undefined;
-declare function set<T, S>(factory: set.Factory<T, S>, required: false): T | undefined;
-declare function set<T>(factory: set.Factory<T>, required?: boolean): T;
-declare function set<T, S>(factory: set.Factory<T, S>, required?: boolean): T;
-declare function set<T>(value: set.Factory<T>, onUpdate: set.Callback<T>): T;
-declare function set<T, S>(value: set.Factory<T, S>, onUpdate: set.Callback<T, S>): T;
+declare function put<T>(factory: set$1.Factory<T>, required: false): T | undefined;
+declare function put<T, S>(factory: set$1.Factory<T, S>, required: false): T | undefined;
+declare function put<T>(factory: set$1.Factory<T>, required?: boolean): T;
+declare function put<T, S>(factory: set$1.Factory<T, S>, required?: boolean): T;
+declare function put<T>(value: set$1.Factory<T>, onUpdate: set$1.Callback<T>): T;
+declare function put<T, S>(value: set$1.Factory<T, S>, onUpdate: set$1.Callback<T, S>): T;
 /**
  * Assign a property with result of a promise.
  */
-declare function set<T>(factory: Promise<T>, required: false): T | undefined;
-declare function set<T>(factory: Promise<T>, required?: boolean): T;
-declare function set<T>(value: Promise<T>, onUpdate: set.Callback<T>): T;
+declare function put<T>(factory: Promise<T>, required: false): T | undefined;
+declare function put<T>(factory: Promise<T>, required?: boolean): T;
+declare function put<T>(value: Promise<T>, onUpdate: set$1.Callback<T>): T;
 /**
  * Assign a property.
  */
-declare function set<T>(factory: T, required: false): T | undefined;
-declare function set<T>(factory: T, required?: boolean): T;
+declare function put<T>(factory: T, required: false): T | undefined;
+declare function put<T>(factory: T, required?: boolean): T;
+declare function put<T>(value: T, onUpdate: set$1.Callback<T>): T;
+
+declare namespace set {
+    type Callback<T, S = any> = (this: S, argument: T) => ((next: T) => void) | Promise<any> | void | boolean;
+}
+/**
+ * Set property with a placeholder.
+ *
+ * Property cannot be accessed until it is defined. If accessed while undefined, a hybrid
+ * `Promise`/`Error` (ala: [Suspense](https://reactjs.org/docs/concurrent-mode-suspense.html)) will be thrown.
+ */
+declare function set<T = any>(): T;
+declare function set<T>(onUpdate: set.Callback<T>): T;
+declare function set<T, S>(onUpdate: set.Callback<T, S>): T;
+declare function set<T>(value: undefined, onUpdate: set.Callback<T>): T;
+declare function set<T, S>(value: undefined, onUpdate: set.Callback<T, S>): T;
 declare function set<T>(value: T, onUpdate: set.Callback<T>): T;
+declare function set<T, S>(value: T, onUpdate: set.Callback<T, S>): T;
 
 /**
  * Create a placeholder for specified Model type.
@@ -643,4 +622,4 @@ declare function useTap<T extends Stateful, K extends Model.Field<T>>(source: T
 declare function useTap<T extends Stateful, R>(source: T | (() => T) | useTap.Tappable, compute: (this: T, from: T) => R, expect: true): Exclude<R, undefined>;
 declare function useTap<T extends Stateful, R>(source: T | (() => T) | useTap.Tappable, compute: (this: T, from: T) => R, expect?: boolean): R;
 
-export { CONTROL, Consumer, Global, LOCAL, MVC as Model, Provider, STATE, Stateful, WHY, act, apply, array, MVC as default, from, parent, ref, set, tap, use, useFrom, useLocal, useModel, useTap };
+export { CONTROL, Consumer, Global, LOCAL, MVC as Model, Provider, STATE, Stateful, WHY, act, apply, array, MVC as default, from, parent, put, ref, set, tap, use, useFrom, useLocal, useModel, useTap };