@expressive/mvc 0.9.4 → 0.9.6

package/lib/index.d.ts

@@ -22,7 +22,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.Values<T>[];
+    get using(): Model.Field<T>[];
     assign(apply: Model.Compat<T>, keys?: any): void;
     add(key: any, value?: boolean | Callback): void;
     commit: () => () => void;
@@ -45,7 +45,7 @@ declare type Debug<T extends {}> = T & {
     /** Current subscriber (if present) while used in a live context (e.g. hook or effect). */
     [LOCAL]?: Subscriber<T>;
     /** Current state of this instance. */
-    [STATE]?: Model.Values<T>;
+    [STATE]?: Model.Export<T>;
     /**
      * Last update causing a refresh to subscribers.
      *
@@ -78,18 +78,18 @@ declare namespace Model {
      *
      * TODO: Should exclude methods
      **/
-    export type Field<T, U extends Model = Model> = Exclude<keyof T, keyof U | keyof Debug<{}>> & string;
+    export type Field<T, E extends Model = Model> = Exclude<keyof T, keyof E | keyof Debug<{}>> & string;
     /**
      * Including but not limited to `keyof T` which are not methods or defined by base Model.
      **/
-    export type Event<T, U extends Model = Model> = Extends<Field<T, U>>;
+    export type Event<T, E extends Model = Model> = Extends<Field<T, E>>;
     /** Object containing managed entries found in T. */
-    export type Entries<T, U extends Model = Model> = {
-        [K in Field<T, U>]: T[K];
+    export type Entries<T, E extends Model = Model> = {
+        [K in Field<T, E>]: T[K];
     };
     /** Object comperable to data found in T. */
-    export type Compat<T, U extends Model = Model> = {
-        [K in Field<T, U>]?: T[K];
+    export type Compat<T, E extends Model = Model> = {
+        [K in Field<T, E>]?: T[K];
     };
     /** Actual value stored in state. */
     export type Value<R> = R extends Ref<infer T> ? T : R;
@@ -103,6 +103,9 @@ declare namespace Model {
     export type Values<T, K extends Field<T> = Field<T>> = {
         [P in K]: Value<T[P]>;
     };
+    export type Export<T, E extends Model = Model> = {
+        [P in Field<T, E>]: Value<T[P]>;
+    };
 }
 declare class Model {
     /**
@@ -124,7 +127,7 @@ declare class Model {
     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(): Model.Export<this>;
     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>[]>;
@@ -460,6 +463,39 @@ declare class MVC extends Model {
     static meta<T, M extends Class>(this: M, from: (this: M, state: M) => T, expect?: boolean): T;
 }
 
+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 class Lookup {
+    private table;
+    get local(): Model[];
+    private key;
+    get(T: Model.Type): any;
+    push(): this;
+    inject(T: Model.Type, I: Model, writable?: boolean): void;
+    pop(): void;
+}
+declare function useContext<T extends Model>(Type: Model.Type<T>, required: false): T | undefined;
+declare function useContext<T extends Model>(Type: Model.Type<T>, arg?: boolean): T;
+declare function useContext<T extends Model>(Type: Model.Type<T>, effect: (found: T) => Callback | void): T;
+declare function useContext<T extends Model, K extends Model.Field<T>>(Type: Model.Type<T>, key: K): T[K];
+
+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;
+declare function useModel<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, 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 namespace Consumer {
     type HasProps<E extends Class> = {
         /** @deprecated - use for instead */
@@ -497,20 +533,6 @@ declare namespace Consumer {
 }
 declare function Consumer<T extends Class>(props: Consumer.Props<T>): any;
 
-declare class Lookup {
-    private table;
-    get local(): Model[];
-    private key;
-    get(T: Model.Type): any;
-    push(): this;
-    inject(T: Model.Type, I: Model, writable?: boolean): void;
-    pop(): void;
-}
-declare function useContext<T extends Model>(Type: Model.Type<T>, required: false): T | undefined;
-declare function useContext<T extends Model>(Type: Model.Type<T>, arg?: boolean): T;
-declare function useContext<T extends Model>(Type: Model.Type<T>, effect: (found: T) => Callback | void): T;
-declare function useContext<T extends Model, K extends Model.Field<T>>(Type: Model.Type<T>, key: K): T[K];
-
 declare namespace Provider {
     type Item = Model | Model.Type;
     type Multiple<T extends Item = Item> = T[] | {
@@ -585,23 +607,4 @@ 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 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;
-declare function useModel<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, 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;
-
 export { Consumer, Debug, Global, MVC, MVC as Model, Provider, add, MVC as default, get, has, ref, run, set, tap, use, useContext, useModel, useTap, useValue };

package/lib/index.esm.js

@@ -1,5 +1,7 @@
 import React, { useState, useMemo } from 'react';
 
+const { assign, create, defineProperties, defineProperty, entries, getPrototypeOf, getOwnPropertyNames, getOwnPropertyDescriptor, getOwnPropertySymbols, values } = Object;
+
 class Issue extends Error {
     constructor() {
         super(...arguments);
@@ -17,8 +19,6 @@ function issues(register) {
     return Library;
 }
 
-const { assign, create, defineProperties, defineProperty, entries, getPrototypeOf, getOwnPropertyNames, getOwnPropertyDescriptor, getOwnPropertySymbols, values } = Object;
-
 const Oops$e = issues({
     NotReady: (model, key) => `Value ${model}.${key} value is not yet available.`,
 });
@@ -1364,43 +1364,6 @@ class MVC extends Model {
     }
 }
 
-const LOCAL = "$debug local";
-const STATE = "$debug state";
-const UPDATE = "$debug update";
-const CONTROL = "$debug controller";
-defineProperties(Model.prototype, {
-    [CONTROL]: {
-        get() {
-            return Control.get(this);
-        }
-    },
-    [LOCAL]: {
-        get() {
-            return Subscriber.get(this);
-        }
-    },
-    [STATE]: {
-        get() {
-            const { state } = Control.get(this);
-            const output = {};
-            state.forEach((value, key) => output[key] = value);
-            return output;
-        }
-    },
-    [UPDATE]: {
-        get() {
-            const source = Subscriber.get(this) || Control.get(this);
-            return source && source.latest;
-        }
-    }
-});
-const Debug = {
-    CONTROL,
-    LOCAL,
-    STATE,
-    UPDATE
-};
-
 const Oops$2 = issues({
     BadProps: () => `Provider expects either a render function, 'get' or 'has' props.`
 });
@@ -1530,5 +1493,42 @@ class Global extends MVC {
 }
 Global.keepAlive = true;
 
+const LOCAL = "$debug local";
+const STATE = "$debug state";
+const UPDATE = "$debug update";
+const CONTROL = "$debug controller";
+defineProperties(Model.prototype, {
+    [CONTROL]: {
+        get() {
+            return Control.get(this);
+        }
+    },
+    [LOCAL]: {
+        get() {
+            return Subscriber.get(this);
+        }
+    },
+    [STATE]: {
+        get() {
+            const { state } = Control.get(this);
+            const output = {};
+            state.forEach((value, key) => output[key] = value);
+            return output;
+        }
+    },
+    [UPDATE]: {
+        get() {
+            const source = Subscriber.get(this) || Control.get(this);
+            return source && source.latest;
+        }
+    }
+});
+const Debug = {
+    CONTROL,
+    LOCAL,
+    STATE,
+    UPDATE
+};
+
 export { Consumer, Debug, Global, MVC, MVC as Model, Provider, add, MVC as default, get, has, ref, run, set, tap, use$1 as use, useContext, useModel, useTap, useValue };
 //# sourceMappingURL=index.esm.js.map