@expressive/mvc 0.9.5 → 0.10.0

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;
@@ -100,9 +100,12 @@ declare namespace Model {
      *
      * Differs from `Entries` as values here will drill into "real" values held by exotics like ref.
      */
-    export type Values<T, K extends Field<T> = Field<T>> = {
+    export type Get<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 {
     /**
@@ -112,11 +115,8 @@ declare class Model {
      */
     is: this;
     constructor();
-    on<P extends Model.Event<this>>(key: P, timeout?: number): Promise<Model.ValueOf<this, P>>;
-    on<P extends Model.Field<this>>(key: P, listener: (this: this, value: this[P], key: P) => void, once?: boolean): Callback;
-    on<P extends Model.Event<this>>(key: P, listener: (this: this, value: undefined, key: P) => void, once?: boolean): 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<P extends Model.Event<this>>(keys?: P | Iterable<P>, timeout?: number): Promise<P[]>;
+    on<P extends Model.Event<this>>(keys: P | Iterable<P>, listener: (this: this, keys: Model.Event<this>[]) => 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;
@@ -124,17 +124,25 @@ 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<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)[]>;
+    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;
+    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)[]>;
+    set<T extends Model.Compat<this>>(source: T, force?: boolean): PromiseLike<(keyof T)[]>;
     /**
      * Clean up side effects and mark this instance for garbage-collection.
      */
-    destroy(): void;
+    end(): void;
     /**
      * Creates a new instance of this controller.
      *
@@ -413,30 +421,42 @@ declare function use<T extends {}>(peer: T, callback?: (i: T) => void): T;
 declare function has<T extends Model>(Type: Model.Type<T>, required: false): T | undefined;
 declare function has<T extends Model>(Type: Model.Type<T>, required?: true): T;
 
+declare namespace MVC {
+    type EffectCallback<T = MVC> = (found: T) => Callback | void;
+}
 declare class MVC extends Model {
+    end(force?: boolean): boolean | void;
+    static global?: boolean;
+    static keepAlive?: boolean;
+    /**
+     * Create a new instance of this model and activate its managed state.
+     *
+     * @param args - arguments sent to constructor
+     */
+    static new<T extends Class>(this: T, ...args: ConstructorParameters<T>): InstanceOf<T>;
     /**
      * **React Hook** - Fetch most instance of this controller from context, if it exists.
      *
      * @param required - Unless false, will throw where instance cannot be found.
      */
-    static get<T extends MVC>(this: Model.Type<T>, required?: boolean): T;
+    static get<T extends MVC>(this: Model.Type<T>, required?: boolean, effectCallback?: MVC.EffectCallback<T>): T;
     /**
      * **React Hook** - Fetch most instance of this controller from context.
      *
      * @param required - If false, may return undefined.
      */
-    static get<T extends MVC>(this: Model.Type<T>, required: false): T | undefined;
-    /**
-     * **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<T extends MVC>(this: Model.Type<T>, required: false, effectCallback?: MVC.EffectCallback<T | undefined>): T | undefined;
     /**
      * **React Hook** - Fetch instance.
      *
      * Effect callback will run once if found, throw if not found.
      * Returned function is called on unmount.
      */
-    static get<I extends MVC>(this: Model.Type<I>, effect: (found: I) => Callback | void): I;
+    static get<I extends MVC>(this: Model.Type<I>, effectCallback: MVC.EffectCallback<I>): I | undefined;
+    /**
+     * **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];
     /**
      * **React Hook** - Fetch and subscribe to instance of this controller within ambient component.
      */
@@ -460,26 +480,21 @@ 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;
+    add(T: Model.Type, I: Model, writable?: boolean): void;
     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 useContext<T extends Model>(Type: Model.Type<T>, required?: boolean): T;
 
-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 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), 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>);
@@ -535,48 +550,24 @@ declare namespace Provider {
     type Multiple<T extends Item = Item> = T[] | {
         [key: string]: T;
     };
-    type Existent<E> = E extends Class ? InstanceType<E> : E extends Model ? E : never;
-    type NormalProps<E, I = Existent<E>> = {
+    type Instance<E> = E extends Class ? InstanceType<E> : E extends Model ? E : never;
+    type NormalProps<E, I = Instance<E>> = {
         for: E;
         children?: React.ReactNode | ((instance: I) => React.ReactNode);
-    } & Model.Compat<I>;
+        and?: Model.Compat<I>;
+    };
     type MultipleProps<T extends Item> = {
         for: Multiple<T>;
         children?: React.ReactNode | (() => React.ReactNode);
-    } & Model.Compat<Existent<T>>;
+        and?: Model.Compat<Instance<T>>;
+    };
     type Props<T extends Item> = MultipleProps<T> | NormalProps<T>;
 }
 declare function Provider<T extends Provider.Item>(props: Provider.Props<T>): React.FunctionComponentElement<React.ProviderProps<Lookup>>;
 
 declare class Global extends MVC {
-    constructor();
-    destroy(force?: boolean): boolean;
+    static global: boolean;
     static keepAlive: boolean;
-    static new<T extends Class>(this: T, ...args: ConstructorParameters<T>): InstanceOf<T>;
-    /**
-     * Update the active instance of this class.
-     * Returns a thenable; resolves after successful update.
-     * If instance does not already exist, one will be created.
-     */
-    static set<T extends typeof Global>(this: T, values: Model.Compat<InstanceOf<T>, Global>): PromiseLike<Model.Field<InstanceOf<T>, Global>[]>;
-    /**
-     * **React Hook** - Fetch most instance of this controller from context, if it exists.
-     *
-     * @param required - If false, may return undefined.
-     */
-    static get<T extends Global>(this: Model.Type<T>, required: false): T | undefined;
-    /**
-     * **React Hook** - Fetch most instance of this controller from context.
-     *
-     * @param required - Unless false, will throw where instance cannot be found.
-     */
-    static get<T extends Global>(this: Model.Type<T>, required?: boolean): T;
-    /**
-     * **React Hook** - Fetch specific value from instance of this controller in context.
-     */
-    static get<T extends Global, K extends Model.Field<T, Global>>(this: Model.Type<T>, key: K): T[K];
-    /** Destroy current instance of Global, if it exists. */
-    static reset(): void;
 }
 
 /**
@@ -604,4 +595,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;
 
-export { Consumer, Debug, Global, MVC, MVC as Model, Provider, add, MVC as default, get, has, ref, run, set, tap, use, useContext, useModel, useTap, useValue };
+export { Consumer, Debug, Global, MVC, MVC as Model, Provider, add, MVC as default, get, has, ref, run, set, tap, use, useContext, useNew, useTap };