@expressive/mvc 0.9.6 → 0.10.0

package/lib/index.d.ts

@@ -100,7 +100,7 @@ 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> = {
@@ -115,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;
@@ -127,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.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>[]>;
-    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.
      *
@@ -416,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.
      */
@@ -463,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>);
@@ -538,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;
 }
 
 /**
@@ -607,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 };