@expressive/mvc 1.0.0-beta.10 → 1.0.0-beta.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@expressive/mvc",
-  "version": "1.0.0-beta.10",
+  "version": "1.0.0-beta.14",
   "description": "Use classes to define state in React!",
   "author": {
     "name": "Gabe Klein",
@@ -27,7 +27,7 @@
     "watch": "rollup --config --sourcemap --watch",
     "prebuild": "rm -rf lib/",
     "publish:pre": "npm version prerelease --preid=beta",
-    "preversion": "jest",
+    "preversion": "jest --coverage",
     "postversion": "npm run build; npm publish",
     "postpublish": "git push; git push --tags; rm -rf lib",
     "coverage": "jest --collectCoverage",

package/types/index.d.ts

@@ -1,4 +1,5 @@
 export {
+    State,
     Model,
     Model as default,
     Singleton

package/types/instructions.d.ts

@@ -5,104 +5,153 @@ import { Async, Class, EffectCallback, InstanceOf } from './types';
  * Run instruction as controller sets itself up.
  * This will specialize the behavior of a given property.
  **/
-export function set <T = any> (
-  instruction: Model.Instruction<T>,
-  name?: string
-): T;
+export function set <T = any> (instruction: Model.Instruction<T>, name?: string): T;
 
 /**
  * Creates a new child-instance of specified controller.
- * 
+ *
  * @param Peer - Type of Model to create and apply to host property.
  * @param callback - Fired after controller is created and ready for use.
  */
- export function use <T extends typeof Model> (Peer: T, callback: (i?: InstanceOf<T>) => void): InstanceOf<T> | undefined;
- export function use <T extends typeof Model> (Peer: T, required: false): InstanceOf<T> | undefined;
- export function use <T extends typeof Model> (Peer: T, required?: true): InstanceOf<T>;
- export function use <T extends Model | undefined> (Peer: () => T, callback?: (i: T) => void): T;
- export function use <T extends Model> (): T | undefined;
+export function use <T extends Class> (Peer: T, callback: (i?: InstanceOf<T>) => void): InstanceOf<T> | undefined;
+
+/**
+ * Creates a new child-instance of specified controller.
+ *
+ * @param Peer - Type of Model to create and apply to host property.
+ * @param required - Property should be non-nullable, will throw if value is set to undefined.
+ */
+export function use <T extends Class> (Peer: T, required: false): InstanceOf<T> | undefined;
+export function use <T extends Class> (Peer: T, required?: true): InstanceOf<T>;
+
+/**
+ * Creates a new child-instance of specified controller.
+ *
+ * @param factory - Generate model for use.
+ * @param callback - Fired after controller is created and ready for use.
+ */
+export function use <T extends Model | undefined> (factory: () => T, callback?: (i: T) => void): T;
+
+/**
+ * Create a child-instance relationship with provided model.
+ *
+ * Note: If `peer` is not already initialized before parent is
+ * (created with `new` as opposed to create method), that model will
+ * attach this via `parent()` instruction. It will not howerver, if
+ * already active.
+ *
+ * @param factory - Instance of model to attach.
+ * @param callback - Fired after controller is attached.
+ */
+export function use <T extends Model> (peer: T, callback?: (i: T) => void): T;
+
+/**
+ * Create a placeholder for specified Model type.
+ */
+export function use <T extends Model> (): T | undefined;
+
+/**
+ * Generate a child controller from specified object. Object's values are be trackable, as would be for a full-model.
+ *
+ * Note: Child will *not* be same object as one provided.
+ */
+export function use <T extends BunchOf<any>> (object: T): T;
 
 /**
  * Generic instruction used by `use()` and `tap()` for recursive subscription.
- * 
+ *
  * @param from - Instruction body is run upon parent create. Return function to fetch current value of field.
  */
 export function child <T extends Model> (from: (this: Model.Controller, key: string) => () => T | undefined): T;
  
- /**
-  * Fetches and assigns the controller which spawned this host.
-  * When parent assigns an instance via `use()` directive, it
-  * will be made available to child upon this request.
-  * 
-  * @param Expects - Type of controller compatible with this class. 
-  * @param required - Throw if controller is created independantly.
-  */
- export function parent <T extends typeof Model> (Expects: T, required: true): InstanceOf<T>;
- export function parent <T extends typeof Model> (Expects: T, required?: false): InstanceOf<T> | undefined;
+/**
+ * Fetches and assigns the controller which spawned this host.
+ * When parent assigns an instance via `use()` directive, it
+ * will be made available to child upon this request.
+ *
+ * @param Expects - Type of controller compatible with this class. 
+ * @param required - Throw if controller is created independantly.
+ */
+export function parent <T extends typeof Model> (Expects: T, required: true): InstanceOf<T>;
+export function parent <T extends typeof Model> (Expects: T, required?: false): InstanceOf<T> | undefined;
+
+/**
+ * Find and attach most applicable instance of Model via context.
+ * 
+ * Host controller will search element-hierarchy relative to where it spawned.
+ * 
+ * @param Type - Type of model to find from context
+ * @param callback -
+ *  - Invoked after context is scanned, is passed result - either found or undefined.
+ *  - If argument is inadequate, but required, your implemention should simply throw.
+ *  - If inadequate and not required, conditionally return false.
+ */
+export function tap <T extends typeof Model> (Type: T, callback?: (instance?: InstanceOf<T>) => void | true): InstanceOf<T>;
+export function tap <T extends typeof Model> (Type: T, callback?: (instance?: InstanceOf<T>) => void | false): InstanceOf<T> | undefined;
  
- /**
-  * Find and attach most applicable instance of Model via context.
-  * 
-  * Expects a `<Provider>` of target controller to exist. 
-  * Host controller will search element-hierarchy relative to where it spawned.
-  * 
-  * @param Type - Type of controller to attach to property. 
-  * @param required - Throw if instance of Type cannot be found.
-  */
- export function tap <T extends Class> (Type: T, required?: boolean): InstanceOf<T>;
+/**
+ * Find and attach most applicable instance of Model via context.
+ *
+ * Expects a `<Provider>` of target controller to exist. 
+ * Host controller will search element-hierarchy relative to where it spawned.
+ *
+ * @param Type - Type of controller to attach to property. 
+ * @param required - Throw if instance of Type cannot be found.
+ */
+export function tap <T extends Class> (Type: T, required?: boolean): InstanceOf<T>;
  
- /**
-  * Sets property to synchronously call effect upon update.
-  * 
-  * @param starting - Beginning value of host property.
-  * @param callback - Effect-callback fired upon set of host property.
-  */
- export function on <T = any> (initial: undefined, callback: EffectCallback<T>): T | undefined;
- export function on <T = any> (initial: T, callback: EffectCallback<T>): T;
+/**
+ * Sets property to synchronously call effect upon update.
+ *
+ * @param starting - Beginning value of host property.
+ * @param callback - Effect-callback fired upon set of host property.
+ */
+export function on <T = any> (initial: undefined, callback: EffectCallback<T>): T | undefined;
+export function on <T = any> (initial: T, callback: EffectCallback<T>): T;
 
- /**
-  * Creates a ref-compatible property for use with components.
-  * Will persist value, and updates to this are made part of controller event-stream.
-  * 
-  * *Output is simultaneously a ref-function and ref-object, use as needed.*
-  * 
-  * @param callback - Optional callback to synchronously fire when reference is first set or does update.
-  */
- export function ref <T = HTMLElement> (callback?: EffectCallback<T>): Model.Ref<T>;
+/**
+ * Creates a ref-compatible property for use with components.
+ * Will persist value, and updates to this are made part of controller event-stream.
+ *
+ * *Output is simultaneously a ref-function and ref-object, use as needed.*
+ *
+ * @param callback - Optional callback to synchronously fire when reference is first set or does update.
+ */
+export function ref <T = HTMLElement> (callback?: EffectCallback<T>): Model.Ref<T>;
 
- /**
-  * Sets an exotic method with managed ready-state. Property accepts an async function.
-  * 
-  * When an act-method is invoked, its `active` property to true for duration of call.
-  * This is emitted as an update to property, both when called and after returns (or throws).
-  * 
-  * **Note:** Subsequent calls will immediately throw if one is still pending.
-  * 
-  * @param action - Action to fire when resulting property is invoked.
-  */
- export function act <T extends Async>(action: T): T & { active: boolean };
+/**
+ * Sets an exotic method with managed ready-state. Property accepts an async function.
+ *
+ * When an act-method is invoked, its `active` property to true for duration of call.
+ * This is emitted as an update to property, both when called and after returns (or throws).
+ *
+ * **Note:** Subsequent calls will immediately throw if one is still pending.
+ *
+ * @param action - Action to fire when resulting property is invoked.
+ */
+export function act <T extends Async> (action: T): T & { active: boolean };
  
- /**
-  * Implement a computed value; output will be generated by provided function.
-  * 
-  * *Alternative to using native getters; works exactly the same!*
-  * 
-  * @param fn - Factory function to generate value and subscribe dependancies.
-  */
- export function from <T, R>(fn: (this: T, on: T) => R): R;
+/**
+ * Implement a computed value; output will be generated by provided function.
+ *
+ * *Alternative to using native getters; works exactly the same!*
+ *
+ * @param fn - Factory function to generate value and subscribe dependancies.
+ */
+export function from <T, R> (fn: (this: T, on: T) => R): R;
 
- /**
-  * Memoized value. Computes and stores a value returned by provided factory. 
-  * Equivalent to a getter, sans the automatic updates.
-  * 
-  * @param compute - Factory for memoized value.
-  * @param lazy - Wait until accessed to introduce value.
-  */
- export function memo <T> (compute: () => T, lazy?: boolean): T;
+/**
+ * Memoized value. Computes and stores a value returned by provided factory. 
+ * Equivalent to a getter, sans the automatic updates.
+ *
+ * @param compute - Factory for memoized value.
+ * @param lazy - Wait until accessed to introduce value.
+ */
+export function memo <T> (compute: () => T, lazy?: boolean): T;
  
- /**
-  * Flag property as not to be tracked. Useful if changes often with no real-time impact.
-  * 
-  * @param value - starting value of property.
-  */
- export function lazy <T> (value?: T): T;
+/**
+ * Flag property as not to be tracked. Useful if changes often with no real-time impact.
+ *
+ * @param value - starting value of property.
+ */
+export function lazy <T> (value?: T): T;

package/types/model.d.ts

@@ -1,6 +1,5 @@
-import Dispatch from './dispatch';
 import Lifecycle from './lifecycle';
-import { Selector } from './selector';
+import { Select, Selector } from './selector';
 import { Class, InstanceOf, Key } from './types';
 
 interface PropertyDescriptor<T> {
@@ -12,6 +11,12 @@ interface PropertyDescriptor<T> {
     set?(v: T): void;
 }
 
+type Argument<T> = T extends (arg: infer U) => any ? U : never;
+
+type Thenable<T> = {
+    then(onFulfilled: (arg: T) => void): void;
+}
+
 export namespace Model {
     /** Exotic value, actual value is contained. */
     interface Ref<T = any> {
@@ -25,7 +30,7 @@ export namespace Model {
      * Property initializer, will run upon instance creation.
      * Optional returned callback will run when once upon first access.
     */
-    type Instruction<T> = (this: Controller, key: string) =>
+    type Instruction<T> = (this: Controller, key: string, thisArg: Controller) =>
         void | GetFunction<T> | PropertyDescriptor<T>;
 
     /** Shallow replacement given all entries of Model */
@@ -96,27 +101,26 @@ export namespace Model {
 
     type SelectField<T> = (arg: Omit<T, keyof Model>) => any;
 
+    type SelectFieldKey<T> = Select.Key<Fields<T>>;
+
+    type Typeof<T, ST, X extends keyof T = Exclude<keyof T, keyof Model>> = {
+        [Key in X]: T[Key] extends ST ? Key : never;
+    }[X];
+
+    type SelectTypeof<T, ST> = Select.Key<Typeof<T, ST>>;
+
     type HandleValue = (value: any) => boolean | void;
 
     export class Controller {
         state: BunchOf<any>;
         subject: {};
 
-        /**
-         * Place a given key's property under management.
-         * 
-         * Note: If property is occupied by an instruction, it will be run.
-         */
-        add(key: string): void;
-
         /** Add property to managed state. */
         manage(key: string, initial: any, effect?: HandleValue): void;
 
         select(using?: Query): string[];
 
-        sets(key: string, effect?: HandleValue): (value: any) => boolean | void;
-
-        watch(target: string | Iterable<string> | Query, handler: Function, squash?: boolean, once?: boolean): Callback;
+        setter(key: string, effect?: HandleValue): (value: any) => boolean | void;
 
         addListener(batch: BunchOf<RequestCallback>): Callback;
 
@@ -125,17 +129,16 @@ export namespace Model {
         include(cb: RequestCallback): void;
     }
 
-    type Listener = {
-        commit(): void;
-        release(): void;
-    }
-      
     export class Subscriber {
         proxy: any;
+        source: any;
+        parent: Controller;
         active: boolean;
         follows: BunchOf<Callback>;
-        dependant: Set<Listener>;
-        parent: Controller;
+        dependant: Set<{
+            commit(): void;
+            release(): void;
+        }>;
 
         follow(key: string, cb?: Callback | undefined): void;
         commit(): Callback;
@@ -148,9 +151,16 @@ declare const CONTROL: unique symbol;
 declare const LOCAL: unique symbol;
 declare const STATE: unique symbol;
 
-export interface Model extends Dispatch, Lifecycle {}
+export abstract class State {
+    /** Controller for this instance. */
+    [CONTROL]: Model.Controller;
+
+    /** Current state of this instance. */
+    [STATE]?: Model.State<this>;
+
+    /** Current subscriber (if present) while used in a live context (e.g. hook or effect). */
+    [LOCAL]?: Model.Subscriber;
 
-export abstract class Model {
     /**
      * Circular reference to `this` controller.
      * 
@@ -210,6 +220,36 @@ export abstract class Model {
      */
     set: this;
 
+    import <O extends Model.Data<this>> (via: O, select?: string[] | Model.SelectFields<this>): void;
+
+    export(): Model.State<this>;
+    export <P extends Model.Fields<this>> (select: P[]): Model.State<this, P>;
+    export <S extends Model.SelectFields<this>> (select: S): Model.State<this, Selector.From<S>>;
+
+    update(): PromiseLike<string[] | false>;
+    update(strict: true): Promise<string[]>;
+    update(strict: false): Promise<false>;
+    update(strict: boolean): Promise<string[] | false>;
+
+    update(keys: Model.Fields<this>): Thenable<string[]>;
+    update(keys: Model.SelectFieldKey<this>): Thenable<string[]>;
+
+    update(keys: Model.Fields<this>, callMethod: boolean): PromiseLike<string[]>;
+    update(keys: Model.SelectFields<this>, callMethod: boolean): PromiseLike<string[]>;
+
+    update<T>(keys: Model.Fields<this>, argument: T): PromiseLike<string[]>;
+    update<T>(keys: Model.SelectFields<this>, argument: T): PromiseLike<string[]>;
+
+    /*
+    Issue with self-reference, using fallback.
+    
+    update(keys: Model.Typeof<this, () => void>, callMethod: boolean): Thenable<string[]>;
+    update(keys: Model.SelectTypeof<this, () => void>, callMethod: boolean): Thenable<string[]>;
+
+    update<T>(keys: Model.Typeof<this, (arg: T) => void>, argument: T): Thenable<string[]>;
+    update<T>(keys: Model.SelectTypeof<this, (arg: T) => void>, argument: T): Thenable<string[]>;
+    */
+
     /** 
      * Mark this instance for garbage-collection and send `willDestroy` event to all listeners.
      * 
@@ -239,33 +279,6 @@ export abstract class Model {
     tap <K extends Model.SelectField<this>> (key: K, expect?: boolean): ReturnType<K>;
     tap <K extends Model.SelectField<this>> (key: K, expect: true): Exclude<ReturnType<K>, undefined>;
 
-    /**
-     * **React Hook** - Attach to instance of this controller within ambient component.
-     * 
-     * This method will fire lifecycle events on given controller.
-     * 
-     * @param id - Argument passed to controller-lifecycle methods. Use to identify the consumer.
-     */
-    tag(id?: Key): this;
-
-     /**
-      * **React Hook** - Attach to instance of this controller within ambient component.
-      * 
-      * This method will fire lifecycle events on given controller.
-      * 
-      * @param idFactory - Will be invoked with fetched instance. Use this to register a tag as-needed.
-      */
-    tag(idFactory: (idFactory: this) => Key | void): this;
-
-    /** Controller for this instance. */
-    [CONTROL]: Model.Controller;
-
-    /** Current state of this instance. */
-    [STATE]?: Model.State<this>;
-
-    /** Current subscriber (if present) while used in a live context (e.g. hook or effect). */
-    [LOCAL]?: Model.Subscriber;
-
     /** Use symbol to access controller of a model. */
     static CONTROL: typeof CONTROL;
 
@@ -289,8 +302,11 @@ export abstract class Model {
      * 
      * Differs from `use()` in lacking subscription and lifecycle events.
      * Much more efficient if you don't need hook-based features.
+     * 
+     * @param args - Arguments passed to constructor of `this`
+     * @param callback - Run after creation of instance.
      */
-    static new <T extends Class> (this: T, ...args: ConstructorParameters<T>): InstanceOf<T>;
+    static new <T extends Class> (this: T, args?: ConstructorParameters<T>, callback?: (instance: InstanceOf<T>) => void): InstanceOf<T>;
 
     /**
      * **React Hook** - Create and attach an instance of this controller a react component.
@@ -298,8 +314,9 @@ export abstract class Model {
      * Note: Model will be destroyed when ambient component unmounts!
      * 
      * @param args - Arguments passed to constructor of `this`
+     * @param callback - Run after creation of instance.
      */
-    static use <T extends Class> (this: T, ...args: ConstructorParameters<T>): InstanceOf<T>;
+    static use <T extends Class> (this: T, args?: ConstructorParameters<T>, callback?: (instance: InstanceOf<T>) => void): InstanceOf<T>;
 
     /**
      * **React Hook** - Similar to `use`, will instanciate a controller bound to ambient component.
@@ -307,7 +324,7 @@ export abstract class Model {
      * 
      * @param data - Data to be applied to controller upon creation.
      */
-    static uses <T extends Class, I extends InstanceOf<T>, D extends Partial<I>> (this: T, data: D): I;
+    static uses <T extends Class, I extends InstanceOf<T>, D extends Partial<I>> (this: T, data: D, only?: (keyof D)[]): I;
 
     /**
      * **React Hook** - Similar to `uses`, will instanciate a controller includive of given data.
@@ -316,7 +333,13 @@ export abstract class Model {
      * 
      * @param data - Data to be observed by controller.
      */
-    static using <T extends Class, I extends InstanceOf<T>, D extends Partial<I>> (this: T, data: D): I;
+    static using <T extends Class, I extends InstanceOf<T>, D extends Partial<I>> (this: T, data: D, only?: (keyof D)[]): I;
+
+    /**
+     * **React Hook** - Locate most relevant instance of this type in context.
+     */
+    static find <T extends Class>(this: T, strict: true): InstanceOf<T>;
+    static find <T extends Class>(this: T, strict?: boolean): InstanceOf<T> | undefined;
 
     /**
      * **React Hook** - Fetch most instance of this controller from context, if it exists.
@@ -362,6 +385,61 @@ export abstract class Model {
     static tap <T extends Class, I extends InstanceOf<T>, K extends Model.Fields<I>> (this: T, key: K, expect: true): Exclude<I[K], undefined>;
     static tap <T extends Class, I extends InstanceOf<T>, K extends Model.SelectField<I>> (this: T, key: K, expect: true): Exclude<ReturnType<K>, undefined>;
 
+    /**
+     * Static equivalent of `x instanceof this`.
+     * 
+     * Will determine if provided class is a subtype of this one. 
+     */
+    static isTypeof <T extends Class>(this: T, subject: any): subject is T;
+}
+
+export interface Model extends Lifecycle {}
+export abstract class Model extends State {
+    // Keyed
+    on <S extends Model.SelectEvents<this>> (via: S, cb: Selector.Callback<S, this>, squash?: false, once?: boolean): Callback;
+    on <P extends Model.EventsCompat<this>> (key: P | P[], listener: UpdateCallback<this, P>, squash?: false, once?: boolean): Callback;
+    // Squash
+    on <S extends Model.SelectEvents<this>> (via: S, cb: (keys: Selector.From<S>[]) => void, squash: true, once?: boolean): Callback;
+    on <P extends Model.EventsCompat<this>> (key: P | P[], listener: (keys: P[]) => void, squash: true, once?: boolean): Callback;
+    // Unknown
+    on <S extends Model.SelectEvents<this>> (via: S, cb: unknown, squash: boolean, once?: boolean): Callback;
+    on <P extends Model.EventsCompat<this>> (key: P | P[], listener: unknown, squash: boolean, once?: boolean): Callback;
+
+    // Keyed
+    once <S extends Model.SelectEvents<this>> (via: S, cb: Selector.Callback<S, this>, squash?: false): Callback;
+    once <P extends Model.EventsCompat<this>> (key: P | P[], listener: UpdateCallback<this, P>, squash?: false): Callback;
+    // Squash
+    once <S extends Model.SelectEvents<this>> (via: S, cb: (keys: Selector.From<S>[]) => void, squash: true): Callback;
+    once <P extends Model.EventsCompat<this>> (key: P | P[], listener: (keys: P[]) => void, squash: true): Callback;
+    // Promise
+    once <S extends Model.SelectEvents<this>> (via: S): Promise<Selector.From<S>[]>;
+    once <P extends Model.EventsCompat<this>> (key: P | P[]): Promise<P[]>;
+    // Unknown
+    once <S extends Model.SelectEvents<this>> (via: S, cb: unknown, squash: boolean): Callback;
+    once <P extends Model.EventsCompat<this>> (key: P | P[], listener: unknown, squash: boolean): Callback;
+
+    effect(callback: (this: this, state: this) => void, select?: Model.SelectFields<this>): Callback;
+    effect(callback: (this: this, state: this) => void, select?: (keyof this)[]): Callback;
+
+    /**
+     * **React Hook** - Attach to instance of this controller within ambient component.
+     * 
+     * This method will fire lifecycle events on given controller.
+     * 
+     * @param id - Argument passed to controller-lifecycle methods. Use to identify the consumer.
+     */
+    tag(id?: Key): this;
+
+     /**
+      * **React Hook** - Attach to instance of this controller within ambient component.
+      * 
+      * This method will fire lifecycle events on given controller.
+      * 
+      * @param idFactory - Will be invoked with fetched instance. Use this to register a tag as-needed.
+      */
+    tag(idFactory: (idFactory: this) => Key | void): this;
+
+
     /**
      * **React Hook** - Attach to instance of this controller within ambient component.
      * 
@@ -395,28 +473,17 @@ export abstract class Model {
      * Documentation TBD.
      */
     static meta <T extends Class, K extends Model.SelectField<T>> (this: T, key?: K): ReturnType<K>;
-
-    /**
-     * **React Hook** - Locate most relevant instance of this type in context.
-     */
-    static find <T extends Class>(this: T): InstanceOf<T>;
-
-    /**
-     * Static equivalent of `x instanceof this`.
-     * 
-     * Will determine if provided class is a subtype of this one. 
-     */
-    static isTypeof <T extends Class>(this: T, subject: any): subject is T;
-
-    /** 
-     * Retreives parent inherited by this class, unless it is base `Model`.
-     */
-    static inherits: typeof Model | undefined;
 }
 
 export class Singleton extends Model {
-    /** Current instance of this controller accessable anywhere. */
-    static current?: Singleton;
+    /**
+     * 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 update<T extends Class>(
+        this: T, updates: Model.Data<InstanceOf<T>>
+    ): PromiseLike<string[] | false>;
 
     /** Destroy current instance of Singleton, if it exists. */
     static reset(): void;

package/types/selector.ts

@@ -1,3 +1,7 @@
+export type KeysOfType<T, ST> = {
+    [Key in keyof T]: T[Key] extends ST ? Key : never
+}[keyof T];
+
 export namespace Selector {
   /**
    * Shallow-recursive clone of source object.
@@ -26,4 +30,18 @@ export namespace Selector {
 
   export type Gets<F extends Function<any>> =
       F extends (spy: any) => infer R ? Values<R> : never;
+
+  export type Callback<S extends Function<any>, T> =
+      (this: T, value: Gets<S>, key: From<S>) => void;
+}
+
+export namespace Select {
+    export type One<T> =
+        (arg: { [K in keyof T]: K }) => string & keyof T;
+
+    export type Key<T extends string | number | symbol> =
+        (arg: { [K in T]: K }) => string & T;
+
+    export type From<T extends One<any>> =
+        T extends (from: any) => infer R ? R : never;
 }

package/types/dispatch.d.ts

@@ -1,55 +0,0 @@
-import { Model } from './model';
-import { Selector } from './selector';
-import { Callback, EffectCallback, UpdateCallback } from './types';
-
-type CallbackFor<S extends Selector.Function<any>, T> =
-  (this: T, value: Selector.Gets<S>, key: Selector.From<S>) => void;
-
-/**
- * Observable Instance
- * 
- * Implements internal value tracking. 
- * Able to be subscribed to, per-value to know when updated.
- */
-interface Dispatch {
-  // Keyed
-  on <S extends Model.SelectEvents<this>> (via: S, cb: CallbackFor<S, this>, squash?: false, once?: boolean): Callback;
-  on <P extends Model.EventsCompat<this>> (key: P | P[], listener: UpdateCallback<this, P>, squash?: false, once?: boolean): Callback;
-  // Squash
-  on <S extends Model.SelectEvents<this>> (via: S, cb: (keys: Selector.From<S>[]) => void, squash: true, once?: boolean): Callback;
-  on <P extends Model.EventsCompat<this>> (key: P | P[], listener: (keys: P[]) => void, squash: true, once?: boolean): Callback;
-  // Unknown
-  on <S extends Model.SelectEvents<this>> (via: S, cb: unknown, squash: boolean, once?: boolean): Callback;
-  on <P extends Model.EventsCompat<this>> (key: P | P[], listener: unknown, squash: boolean, once?: boolean): Callback;
-
-  // Keyed
-  once <S extends Model.SelectEvents<this>> (via: S, cb: CallbackFor<S, this>, squash?: false): Callback;
-  once <P extends Model.EventsCompat<this>> (key: P | P[], listener: UpdateCallback<this, P>, squash?: false): Callback;
-  // Squash
-  once <S extends Model.SelectEvents<this>> (via: S, cb: (keys: Selector.From<S>[]) => void, squash: true): Callback;
-  once <P extends Model.EventsCompat<this>> (key: P | P[], listener: (keys: P[]) => void, squash: true): Callback;
-  // Promise
-  once <S extends Model.SelectEvents<this>> (via: S): Promise<Selector.From<S>[]>;
-  once <P extends Model.EventsCompat<this>> (key: P | P[]): Promise<P[]>;
-  // Unknown
-  once <S extends Model.SelectEvents<this>> (via: S, cb: unknown, squash: boolean): Callback;
-  once <P extends Model.EventsCompat<this>> (key: P | P[], listener: unknown, squash: boolean): Callback;
-
-  effect(callback: EffectCallback<this>, select?: Model.SelectFields<this>): Callback;
-  effect(callback: EffectCallback<this>, select?: (keyof this)[]): Callback;
-
-  import <O extends Model.Data<this>> (via: O, select?: string[] | Model.SelectFields<this>): void;
-
-  export(): Model.State<this>;
-  export <P extends Model.Fields<this>> (select: P[]): Model.State<this, P>;
-  export <S extends Model.SelectFields<this>> (select: S): Model.State<this, Selector.From<S>>;
-
-  update(strict: true): Promise<string[]>;
-  update(strict: false): Promise<false>;
-  update(strict?: boolean): Promise<string[] | false>;
-  update(keys: Model.Fields<this>[]): Promise<string[]>;
-  update(keys: Model.Fields<this>): Promise<string[]>;
-  update(keys: Model.SelectFields<this>): Promise<string[]>;
-}
-
-export = Dispatch;