@expressive/mvc 0.10.0 → 0.10.1

package/lib/index.d.ts

@@ -4,6 +4,9 @@ type Callback = () => void;
 type Class = new (...args: any[]) => any;
 type InstanceOf<T> = T extends { prototype: infer U } ? U : never;
 
+/** Type may not be undefined - instead will be null.  */
+type NoVoid<T> = T extends undefined ? null : T;
+
 declare type Listener = {
     commit(): void;
     release(): void;
@@ -22,7 +25,7 @@ declare class Subscriber<T extends {} = any> {
     dependant: Set<Listener>;
     watch: Map<any, boolean | (() => true | void)>;
     constructor(parent: Control<T>, onUpdate: Subscriber.OnEvent);
-    get using(): Model.Field<T>[];
+    get using(): Model.Key<T>[];
     assign(apply: Model.Compat<T>, keys?: any): void;
     add(key: any, value?: boolean | Callback): void;
     commit: () => () => void;
@@ -71,6 +74,7 @@ declare namespace Model {
     export type Methods<T> = {
         [K in keyof T]: T[K] extends Ref ? never : T[K] extends Function ? K : never;
     }[keyof T];
+    type BuiltIn = keyof Model | keyof Debug<{}>;
     /**
      * Subset of `keyof T` which are not methods or defined by base Model U.
      *
@@ -78,18 +82,18 @@ declare namespace Model {
      *
      * TODO: Should exclude methods
      **/
-    export type Field<T, E extends Model = Model> = Exclude<keyof T, keyof E | keyof Debug<{}>> & string;
+    export type Key<T> = Exclude<keyof T, BuiltIn> & string;
     /**
      * Including but not limited to `keyof T` which are not methods or defined by base Model.
      **/
-    export type Event<T, E extends Model = Model> = Extends<Field<T, E>>;
+    export type Event<T> = Extends<Key<T>>;
     /** Object containing managed entries found in T. */
-    export type Entries<T, E extends Model = Model> = {
-        [K in Field<T, E>]: T[K];
+    export type Entries<T> = {
+        [K in Key<T>]: T[K];
     };
     /** Object comperable to data found in T. */
-    export type Compat<T, E extends Model = Model> = {
-        [K in Field<T, E>]?: T[K];
+    export type Compat<T> = {
+        [K in Key<T>]?: T[K];
     };
     /** Actual value stored in state. */
     export type Value<R> = R extends Ref<infer T> ? T : R;
@@ -100,11 +104,11 @@ declare namespace Model {
      *
      * Differs from `Entries` as values here will drill into "real" values held by exotics like ref.
      */
-    export type Get<T, K extends Field<T> = Field<T>> = {
+    export type Get<T, K extends Key<T> = Key<T>> = {
         [P in K]: Value<T[P]>;
     };
     export type Export<T, E extends Model = Model> = {
-        [P in Field<T, E>]: Value<T[P]>;
+        [P in Key<T>]: Value<T[P]>;
     };
 }
 declare class Model {
@@ -125,16 +129,16 @@ declare class Model {
     on(current: true): Promise<Model.Event<this>[]>;
     on(current: null): Promise<null>;
     get(): Model.Export<this>;
-    get<P extends Model.Field<this>>(property: P): this[P];
-    get<P extends Model.Field<this>>(property: P, timeout: number): Promise<this[P]>;
-    get<P extends Model.Field<this>>(property: P, onChange: true): Promise<this[P]>;
-    get<P extends Model.Field<this>>(property: P, onChange: boolean): this[P] | Promise<this[P]>;
-    get<P extends Model.Field<this>>(property: P, listener: (this: this, value: this[P], key: P[]) => void): Callback;
-    get<P extends Model.Field<this>>(select: Iterable<P>): Model.Get<this, P>;
-    get<P extends Model.Field<this>>(select: Iterable<P>, timeout: number): Promise<Model.Get<this, P>>;
-    get<P extends Model.Field<this>>(select: Iterable<P>, onChange: true): Promise<Model.Get<this, P>>;
-    get<P extends Model.Field<this>>(select: Iterable<P>, onChange: boolean): Model.Get<this, P> | Promise<Model.Get<this, P>>;
-    get<P extends Model.Field<this>>(select: Iterable<P>, listener: (this: this, value: Model.Get<this, P>, key: P[]) => void): Callback;
+    get<P extends Model.Key<this>>(property: P): this[P];
+    get<P extends Model.Key<this>>(property: P, timeout: number): Promise<this[P]>;
+    get<P extends Model.Key<this>>(property: P, onChange: true): Promise<this[P]>;
+    get<P extends Model.Key<this>>(property: P, onChange: boolean): this[P] | Promise<this[P]>;
+    get<P extends Model.Key<this>>(property: P, listener: (this: this, value: this[P], key: P[]) => void): Callback;
+    get<P extends Model.Key<this>>(select: Iterable<P>): Model.Get<this, P>;
+    get<P extends Model.Key<this>>(select: Iterable<P>, timeout: number): Promise<Model.Get<this, P>>;
+    get<P extends Model.Key<this>>(select: Iterable<P>, onChange: true): Promise<Model.Get<this, P>>;
+    get<P extends Model.Key<this>>(select: Iterable<P>, onChange: boolean): Model.Get<this, P> | Promise<Model.Get<this, P>>;
+    get<P extends Model.Key<this>>(select: Iterable<P>, listener: (this: this, value: Model.Get<this, P>, key: P[]) => void): Callback;
     set(key: Model.Event<this>): PromiseLike<readonly Model.Event<this>[]>;
     set<K extends Model.Event<this>>(key: Model.Event<this>, value: Model.ValueOf<this, K>): PromiseLike<readonly Model.Event<this>[]>;
     set<T extends Model.Compat<this>>(source: T, select: (keyof T)[]): PromiseLike<(keyof T)[]>;
@@ -185,8 +189,8 @@ declare class Control<T extends {} = any> {
     subscribe(callback: Subscriber.OnEvent<T>): Model.Subscriber<T>;
     watch(key: keyof T & string): 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;
+    ref<K extends Model.Key<T>>(key: K, handler?: (this: T, value: T[K]) => boolean | void): (value: any) => void;
+    update(key: Model.Key<T>): void;
     clear(): void;
     static get<T extends {}>(from: T): Control<T> | undefined;
     static for<T extends {}>(subject: T): Control<T>;
@@ -317,10 +321,10 @@ declare namespace ref {
     }
     /** Object with references to all managed values of `T`. */
     type Proxy<T extends Model> = {
-        [P in Model.Field<T>]-?: Model.Ref<T[P]>;
+        [P in Model.Key<T>]-?: Model.Ref<T[P]>;
     };
     type CustomProxy<T extends Model, R> = {
-        [P in Model.Field<T>]-?: R;
+        [P in Model.Key<T>]-?: R;
     };
 }
 /**
@@ -340,7 +344,7 @@ declare function ref<T extends Model>(target: T): ref.Proxy<T>;
  * @param target - Source model from which to reference values.
  * @param mapper - Function producing the placeholder value for any given property.
  */
-declare function ref<O extends Model, R>(target: O, mapper: (key: Model.Field<O>) => R): ref.CustomProxy<O, R>;
+declare function ref<O extends Model, R>(target: O, mapper: (key: Model.Key<O>) => R): ref.CustomProxy<O, R>;
 /**
  * Creates a ref-compatible property.
  * Will persist value, and updates to this are made part of controller event-stream.
@@ -456,19 +460,19 @@ declare class MVC extends Model {
     /**
      * **React Hook** - Fetch specific value from instance of this controller in context.
      */
-    static get<I extends MVC, K extends Model.Field<I>>(this: Model.Type<I>, key: K): I[K];
+    static get<I extends MVC, K extends Model.Key<I>>(this: Model.Type<I>, key: K): I[K];
     /**
      * **React Hook** - Fetch and subscribe to instance of this controller within ambient component.
      */
     static tap<T extends MVC>(this: Model.Type<T>): T;
-    static tap<T extends MVC, K extends Model.Field<T>>(this: Model.Type<T>, key: K, expect: true): Exclude<T[K], undefined>;
-    static tap<T extends MVC, K extends Model.Field<T>>(this: Model.Type<T>, key: K, expect?: boolean): T[K];
-    static tap<T extends MVC, R>(this: Model.Type<T>, connect: (this: T, model: T) => () => R): R;
-    static tap<T extends MVC, R>(this: Model.Type<T>, connect: (this: T, model: T) => (() => R) | null): R | null;
+    static tap<T extends MVC, K extends Model.Key<T>>(this: Model.Type<T>, key: K, expect: true): Exclude<T[K], undefined>;
+    static tap<T extends MVC, K extends Model.Key<T>>(this: Model.Type<T>, key: K, expect?: boolean): NoVoid<T[K]>;
+    static tap<T extends MVC, R>(this: Model.Type<T>, connect: (this: T, model: T) => () => R): NoVoid<R>;
+    static tap<T extends MVC, R>(this: Model.Type<T>, connect: (this: T, model: T) => (() => R) | null): NoVoid<R> | null;
     static tap<T extends MVC, R>(this: Model.Type<T>, compute: (this: T, model: T) => Promise<R> | R, expect: true): Exclude<R, undefined>;
-    static tap<T extends MVC, R>(this: Model.Type<T>, compute: (this: T, model: T) => Promise<R>, expect?: boolean): R | undefined;
-    static tap<T extends MVC, R>(this: Model.Type<T>, compute: (this: T, model: T) => R, expect?: boolean): R;
-    static use<I extends MVC>(this: Model.Type<I>, watch: Model.Field<I>[], callback?: (instance: I) => void): I;
+    static tap<T extends MVC, R>(this: Model.Type<T>, compute: (this: T, model: T) => Promise<R>, expect?: boolean): NoVoid<R> | null;
+    static tap<T extends MVC, R>(this: Model.Type<T>, compute: (this: T, model: T) => R, expect?: boolean): NoVoid<R>;
+    static use<I extends MVC>(this: Model.Type<I>, watch: Model.Key<I>[], callback?: (instance: I) => void): I;
     static use<I extends MVC>(this: Model.Type<I>, callback?: (instance: I) => void): I;
     static use<I extends MVC>(this: Model.Type<I>, apply: Model.Compat<I>, keys?: Model.Event<I>[]): I;
     static meta<T extends Class>(this: T): T;
@@ -493,20 +497,20 @@ declare function useContext<T extends Model>(Type: Model.Type<T>, required: fals
 declare function useContext<T extends Model>(Type: Model.Type<T>, required?: boolean): T;
 
 declare function useNew<T extends Model>(source: Model.Type<T> | (() => T), callback?: (instance: T) => void): T;
-declare function useNew<T extends Model>(source: Model.Type<T> | (() => T), watch: Model.Field<T>[], callback?: (instance: T) => void): T;
+declare function useNew<T extends Model>(source: Model.Type<T> | (() => T), watch: Model.Key<T>[], callback?: (instance: T) => void): T;
 declare function useNew<T extends Model>(source: Model.Type<T> | (() => T), apply: Model.Compat<T>, keys?: Model.Event<T>[]): T;
 
 declare namespace useTap {
     type Source<T extends Model> = T | Model.Type<T> | (() => T | Model.Type<T>);
 }
 declare function useTap<T extends Model>(source: useTap.Source<T>): T;
-declare function useTap<T extends Model, K extends Model.Field<T>>(source: useTap.Source<T>, path: K, expect: true): Exclude<T[K], undefined>;
-declare function useTap<T extends Model, K extends Model.Field<T>>(source: useTap.Source<T>, path: K, expect?: boolean): T[K];
-declare function useTap<T extends Model, R>(source: useTap.Source<T>, connect: (this: T, model: T) => () => R): R;
-declare function useTap<T extends Model, R>(source: useTap.Source<T>, connect: (this: T, model: T) => (() => R) | null): R | null;
+declare function useTap<T extends Model, K extends Model.Key<T>>(source: useTap.Source<T>, path: K, expect: true): Exclude<T[K], undefined>;
+declare function useTap<T extends Model, K extends Model.Key<T>>(source: useTap.Source<T>, path: K, expect?: boolean): NoVoid<T[K]>;
+declare function useTap<T extends Model, R>(source: useTap.Source<T>, connect: (this: T, model: T) => () => R): NoVoid<R>;
+declare function useTap<T extends Model, R>(source: useTap.Source<T>, connect: (this: T, model: T) => (() => R) | null): NoVoid<R> | null;
 declare function useTap<T extends Model, R>(source: useTap.Source<T>, compute: (this: T, model: T) => Promise<R> | R, expect: true): Exclude<R, undefined>;
-declare function useTap<T extends Model, R>(source: useTap.Source<T>, compute: (this: T, model: T) => Promise<R>, expect?: boolean): R | undefined;
-declare function useTap<T extends Model, R>(source: useTap.Source<T>, compute: (this: T, model: T) => R, expect?: boolean): R;
+declare function useTap<T extends Model, R>(source: useTap.Source<T>, compute: (this: T, model: T) => Promise<R>, expect?: boolean): NoVoid<R> | null;
+declare function useTap<T extends Model, R>(source: useTap.Source<T>, compute: (this: T, model: T) => R, expect?: boolean): NoVoid<R>;
 
 declare namespace Consumer {
     type HasProps<E extends Class> = {

package/lib/index.esm.js

@@ -1324,9 +1324,11 @@ function useValue(source, compute, suspend) {
         }
         defineProperty(sub, "proxy", {
             get() {
-                if (value === undefined && suspend)
+                if (value !== undefined)
+                    return value;
+                if (suspend)
                     throw new Promise(res => retry = res);
-                return value;
+                return null;
             }
         });
         return sub;