@expressive/mvc 1.0.0-beta.20 → 1.0.0-beta.21

package/lib/index.js

@@ -313,18 +313,17 @@ function eventsFor(prefix) {
 }
 
 const CONTROL = Symbol("control");
-const CREATE = Symbol("start");
 const LOCAL = Symbol("local");
 const STATE = Symbol("state");
-const Pending = new Map();
 function manage(src) {
     return src[CONTROL];
 }
-function set(instruction, label) {
-    const name = label || instruction.name || "pending";
+const Pending = new Map();
+function apply(fn, label) {
+    const name = label || fn.name || "pending";
     const placeholder = Symbol(`${name} instruction`);
-    Pending.set(placeholder, function set(key) {
-        let output = instruction.call(this, key, this);
+    function setup(key) {
+        let output = fn.call(this, key, this);
         if (typeof output == "function") {
             const getter = output;
             output = Object.assign(Object.assign({}, getOwnPropertyDescriptor(this.subject, key)), { get() {
@@ -333,7 +332,8 @@ function set(instruction, label) {
         }
         if (output)
             defineProperty(this.subject, key, output);
-    });
+    }
+    Pending.set(placeholder, setup);
     return placeholder;
 }
 class Controller {
@@ -345,14 +345,10 @@ class Controller {
         this.waiting = [];
     }
     static setup(onto) {
-        const create = onto[CREATE];
         const control = new this(onto);
-        const after = create && create.call(onto, control);
         defineLazy(onto, CONTROL, () => {
             onto[STATE] = control.state;
             control.start();
-            if (after)
-                after();
             if (onto.didCreate)
                 onto.didCreate();
             return control;
@@ -457,42 +453,44 @@ function keys(from, using) {
     return from.select(using);
 }
 
-const attach = (from, name) => set(function attach(key) {
-    const proxyCache = new WeakMap();
-    const getCurrent = from.call(this, key);
-    function subscribe(sub) {
-        let child;
-        function start() {
-            const instance = getCurrent();
-            if (instance) {
-                child = new Subscriber(instance, sub.onUpdate);
-                if (sub.active)
-                    child.commit();
-                sub.dependant.add(child);
-                proxyCache.set(sub, child.proxy);
+function child(from, name) {
+    return apply(function child(key) {
+        const proxyCache = new WeakMap();
+        const getCurrent = from.call(this, key);
+        function subscribe(sub) {
+            let child;
+            function start() {
+                const instance = getCurrent();
+                if (instance) {
+                    child = new Subscriber(instance, sub.onUpdate);
+                    if (sub.active)
+                        child.commit();
+                    sub.dependant.add(child);
+                    proxyCache.set(sub, child.proxy);
+                }
             }
-        }
-        function refresh() {
-            if (child) {
-                child.release();
-                sub.dependant.delete(child);
-                proxyCache.set(sub, undefined);
-                child = undefined;
+            function refresh() {
+                if (child) {
+                    child.release();
+                    sub.dependant.delete(child);
+                    proxyCache.set(sub, undefined);
+                    child = undefined;
+                }
+                start();
+                sub.onUpdate();
             }
             start();
-            sub.onUpdate();
+            sub.follow(key, refresh);
         }
-        start();
-        sub.follow(key, refresh);
-    }
-    return (local) => {
-        if (!local)
-            return getCurrent();
-        if (!proxyCache.has(local))
-            subscribe(local);
-        return proxyCache.get(local);
-    };
-}, name || from.name);
+        return (local) => {
+            if (!local)
+                return getCurrent();
+            if (!proxyCache.has(local))
+                subscribe(local);
+            return proxyCache.get(local);
+        };
+    }, name || from.name);
+}
 
 const Oops$7 = issues({
     HasPropertyUndefined: (control, property) => `${control}.${property} is marked as required for this render.`
@@ -556,6 +554,56 @@ function useModel(Type, args, callback) {
     return hook.proxy;
 }
 
+const Oops$6 = issues({
+    CantAttachGlobal: (parent, child) => `Singleton '${parent}' attempted to attach '${child}' but it is not also a singleton.`,
+    AmbientRequired: (requested, requester, key) => `Attempted to find an instance of ${requested} in context. It is required for [${requester}.${key}], but one could not be found.`
+});
+const PendingContext = new WeakMap();
+const ContextWasUsed = new WeakMap();
+function tap(type, argument) {
+    return child(function tap(key) {
+        return pendingAccess(this.subject, type, key, argument);
+    });
+}
+function pendingAccess(from, type, key, argument) {
+    if ("current" in type)
+        return () => type.current;
+    if ("current" in from.constructor)
+        throw Oops$6.CantAttachGlobal(from, type.name);
+    let instance;
+    getPending(from).push(context => {
+        instance = context.get(type);
+        if (typeof argument == "function") {
+            if (argument(instance) === false)
+                instance = undefined;
+        }
+        else if (!instance && argument)
+            throw Oops$6.AmbientRequired(type.name, from, key);
+    });
+    return () => instance;
+}
+function usePeerContext(subject) {
+    if (ContextWasUsed.has(subject)) {
+        if (ContextWasUsed.get(subject))
+            useLookup();
+        return;
+    }
+    const pending = PendingContext.get(subject);
+    if (pending) {
+        const local = useLookup();
+        for (const init of pending)
+            init(local);
+        PendingContext.delete(subject);
+    }
+    ContextWasUsed.set(subject, !!pending);
+}
+function getPending(subject) {
+    let pending = PendingContext.get(subject);
+    if (!pending)
+        PendingContext.set(subject, pending = []);
+    return pending;
+}
+
 class Lookup {
     constructor() {
         this.table = new Map();
@@ -611,7 +659,7 @@ class Lookup {
     }
 }
 
-const Oops$6 = issues({
+const Oops$5 = issues({
     NoProviderType: () => `Provider 'of' prop must be Model, typeof Model or a collection of them.`,
     NothingInContext: (name) => `Couldn't find ${name} in context; did you forget to use a Provider?`,
     BadConsumerProps: () => `Provider expects either a render function, 'get' or 'has' props.`
@@ -621,7 +669,7 @@ const useLookup = () => react.useContext(LookupContext);
 function useFromContext(Type, strict) {
     const instance = useLookup().get(Type);
     if (!instance && strict)
-        throw Oops$6.NothingInContext(Type.name);
+        throw Oops$5.NothingInContext(Type.name);
     return instance;
 }
 function Consumer(props) {
@@ -632,13 +680,13 @@ function Consumer(props) {
     if (typeof callback == "function")
         callback(Control.get(!!has));
     else
-        throw Oops$6.BadConsumerProps();
+        throw Oops$5.BadConsumerProps();
     return null;
 }
 function useNewContext(from, inject) {
     return react.useMemo(() => {
         if (!inject)
-            throw Oops$6.NoProviderType();
+            throw Oops$5.NoProviderType();
         const context = from.push(inject);
         for (const instance of context.local)
             for (const apply of getPending(instance))
@@ -681,63 +729,74 @@ function Provider(props) {
         : render);
 }
 
-const Oops$5 = issues({
-    CantAttachGlobal: (parent, child) => `Singleton '${parent}' attempted to attach '${child}' but it is not also a singleton.`,
-    AmbientRequired: (requested, requester, key) => `Attempted to find an instance of ${requested} in context. It is required for [${requester}.${key}], but one could not be found.`
-});
-const PendingContext = new WeakMap();
-const ContextWasUsed = new WeakMap();
-const tap = (type, argument) => attach(function tap(key) {
-    return pendingAccess(this.subject, type, key, argument);
-});
-function pendingAccess(from, type, key, argument) {
-    if ("current" in type)
-        return () => type.current;
-    if ("current" in from.constructor)
-        throw Oops$5.CantAttachGlobal(from, type.name);
-    let instance;
-    getPending(from).push(context => {
-        instance = context.get(type);
-        if (typeof argument == "function") {
-            if (argument(instance) === false)
-                instance = undefined;
-        }
-        else if (!instance && argument)
-            throw Oops$5.AmbientRequired(type.name, from, key);
-    });
-    return () => instance;
-}
-function usePeerContext(subject) {
-    if (ContextWasUsed.has(subject)) {
-        if (ContextWasUsed.get(subject))
-            useLookup();
-        return;
-    }
-    const pending = PendingContext.get(subject);
-    if (pending) {
-        const local = useLookup();
-        for (const init of pending)
-            init(local);
-        PendingContext.delete(subject);
-    }
-    ContextWasUsed.set(subject, !!pending);
-}
-function getPending(subject) {
-    let pending = PendingContext.get(subject);
-    if (!pending)
-        PendingContext.set(subject, pending = []);
-    return pending;
-}
-
 const Oops$4 = issues({
     StrictUpdate: (expected) => `Strict update() did ${expected ? "not " : ""}find pending updates.`,
     NoChaining: () => `Then called with undefined; update promise will never catch nor supports chaining.`
 });
-class State {
+const useComponentLifecycle = lifecycle("component");
+class Model {
     constructor() {
-        Controller.setup(this);
+        const control = Controller.setup(this);
         define(this, "get", this);
         define(this, "set", this);
+        defer(control, "on");
+        defer(control, "effect");
+        control.include(() => {
+            delete this.on;
+            delete this.effect;
+        });
+    }
+    tap(path, expect) {
+        const proxy = useWatcher(this, path, expect);
+        this.update("willRender", true);
+        return proxy;
+    }
+    tag(id) {
+        return useSubscriber(this, id);
+    }
+    on(subset, handler, squash, once) {
+        const control = manage(this);
+        const set = keys(control, subset);
+        const batch = {};
+        const remove = control.addListener(batch);
+        const callback = squash
+            ? handler.bind(this)
+            : (frame) => {
+                for (const key of frame)
+                    if (set.includes(key))
+                        handler.call(this, control.state[key], key);
+            };
+        const handle = once
+            ? (k) => { remove(); callback(k); }
+            : callback;
+        for (const key of set)
+            batch[key] = handle;
+        ensure(control, set);
+        return remove;
+    }
+    once(select, callback, squash) {
+        if (callback)
+            return this.on(select, callback, squash, true);
+        else
+            return new Promise(resolve => {
+                this.on(select, resolve, true, true);
+            });
+    }
+    effect(callback, select) {
+        const control = manage(this);
+        let target = this;
+        const effect = createEffect(callback);
+        const invoke = () => effect.call(target, target);
+        if (select) {
+            invoke();
+            return this.on(select, invoke, true);
+        }
+        else {
+            const sub = new Subscriber(control, invoke);
+            target = sub.proxy;
+            invoke();
+            return sub.commit();
+        }
     }
     import(from, subset) {
         for (const key of keys(manage(this), subset))
@@ -788,11 +847,6 @@ class State {
     toString() {
         return this.constructor.name;
     }
-    tap(path, expect) {
-        const proxy = useWatcher(this, path, expect);
-        this.update("willRender", true);
-        return proxy;
-    }
     static create(...args) {
         const instance = new this(...args);
         manage(instance);
@@ -803,19 +857,6 @@ class State {
         instance.update("willRender", true);
         return instance;
     }
-    static use(args, callback) {
-        return useModel(this, args, callback);
-    }
-    static uses(props, only) {
-        return this.use([], instance => {
-            instance.import(props, only);
-        });
-    }
-    static using(props, only) {
-        const instance = this.use([]);
-        instance.import(props, only);
-        return instance;
-    }
     static find(strict) {
         return useFromContext(this, strict);
     }
@@ -830,72 +871,8 @@ class State {
     static tap(key, expect) {
         return this.find(true).tap(key, expect);
     }
-    static isTypeof(maybe) {
-        return (typeof maybe == "function" &&
-            maybe.prototype instanceof this);
-    }
-}
-State.CONTROL = CONTROL;
-State.STATE = STATE;
-State.INIT = CREATE;
-State.LOCAL = LOCAL;
-
-const useComponentLifecycle = lifecycle("component");
-class Model extends State {
-    [CREATE](using) {
-        defer(using, "on");
-        defer(using, "effect");
-        return () => {
-            delete this.on;
-            delete this.effect;
-        };
-    }
-    on(subset, handler, squash, once) {
-        const control = manage(this);
-        const set = keys(control, subset);
-        const batch = {};
-        const remove = control.addListener(batch);
-        const callback = squash
-            ? handler.bind(this)
-            : (frame) => {
-                for (const key of frame)
-                    if (set.includes(key))
-                        handler.call(this, control.state[key], key);
-            };
-        const handle = once
-            ? (k) => { remove(); callback(k); }
-            : callback;
-        for (const key of set)
-            batch[key] = handle;
-        ensure(control, set);
-        return remove;
-    }
-    once(select, callback, squash) {
-        if (callback)
-            return this.on(select, callback, squash, true);
-        else
-            return new Promise(resolve => {
-                this.on(select, resolve, true, true);
-            });
-    }
-    effect(callback, select) {
-        const control = manage(this);
-        let target = this;
-        const effect = createEffect(callback);
-        const invoke = () => effect.call(target, target);
-        if (select) {
-            invoke();
-            return this.on(select, invoke, true);
-        }
-        else {
-            const sub = new Subscriber(control, invoke);
-            target = sub.proxy;
-            invoke();
-            return sub.commit();
-        }
-    }
-    tag(id) {
-        return useSubscriber(this, id);
+    static tag(id) {
+        return this.find(true).tag(id);
     }
     static use(args, callback) {
         const instance = useModel(this, args, callback);
@@ -903,13 +880,27 @@ class Model extends State {
         usePeerContext(instance.get);
         return instance;
     }
-    static tag(id) {
-        return this.find(true).tag(id);
+    static uses(props, only) {
+        return this.use([], instance => {
+            instance.import(props, only);
+        });
+    }
+    static using(props, only) {
+        const instance = this.use([]);
+        instance.import(props, only);
+        return instance;
     }
     static meta(path) {
         return useWatcher(this, path);
     }
+    static isTypeof(maybe) {
+        return (typeof maybe == "function" &&
+            maybe.prototype instanceof this);
+    }
 }
+Model.CONTROL = CONTROL;
+Model.STATE = STATE;
+Model.LOCAL = LOCAL;
 defineLazy(Model, CONTROL, function () {
     return new Controller(this).start();
 });
@@ -939,73 +930,86 @@ function bootstrap(object) {
         defineProperty(control, key, breakdown[key]);
     return control;
 }
-const use = (input, argument) => attach(function use(key) {
-    let instance;
-    const update = (next) => {
-        instance =
-            next instanceof Model ? next :
-                next && bootstrap(next);
-        if (instance) {
-            Parent.set(instance, this.subject);
-            manage(instance);
+function use(input, argument) {
+    return child(function use(key) {
+        let instance;
+        const update = (next) => {
+            instance =
+                next instanceof Model ? next :
+                    next && bootstrap(next);
+            if (instance) {
+                Parent.set(instance, this.subject);
+                manage(instance);
+            }
+            if (typeof argument == "function")
+                argument(instance);
+            else if (!instance && argument !== false)
+                throw Oops$3.UndefinedNotAllowed(key);
+        };
+        if (input) {
+            instance =
+                Model.isTypeof(input) ? new input() :
+                    input instanceof Model ? input :
+                        typeof input === "function" ? input() :
+                            typeof input === "object" ? bootstrap(input) :
+                                Oops$3.BadArgument(typeof input).throw();
+            if (instance)
+                update(instance);
         }
-        if (typeof argument == "function")
-            argument(instance);
-        else if (!instance && argument !== false)
-            throw Oops$3.UndefinedNotAllowed(key);
-    };
-    if (input) {
-        instance =
-            Model.isTypeof(input) ? new input() :
-                input instanceof Model ? input :
-                    typeof input === "function" ? input() :
-                        typeof input === "object" ? bootstrap(input) :
-                            Oops$3.BadArgument(typeof input).throw();
-        if (instance)
-            update(instance);
-    }
-    else
-        argument = false;
-    this.manage(key, instance, update);
-    return () => instance;
-});
-const parent = (Expects, required) => set(function parent() {
-    const child = this.subject;
-    const expected = Expects.name;
-    const value = Parent.get(this.subject);
-    if (!value) {
-        if (required)
-            throw Oops$3.ParentRequired(expected, child);
-    }
-    else if (!(value instanceof Expects))
-        throw Oops$3.UnexpectedParent(expected, child, value);
-    return { value };
-});
+        else
+            argument = false;
+        this.manage(key, instance, update);
+        return () => instance;
+    });
+}
+function parent(Expects, required) {
+    return apply(function parent() {
+        const child = this.subject;
+        const expected = Expects.name;
+        const value = Parent.get(this.subject);
+        if (!value) {
+            if (required)
+                throw Oops$3.ParentRequired(expected, child);
+        }
+        else if (!(value instanceof Expects))
+            throw Oops$3.UnexpectedParent(expected, child, value);
+        return { value };
+    });
+}
 
 const Oops$2 = issues({
     DuplicateAction: (key) => `Invoked action ${key} but one is already active.`,
     BadComputedSource: (model, property, got) => `Bad from-instruction provided to ${model}.${property}. Expects an arrow-function or a Model as source. Got ${got}.`,
     PeerNotAllowed: (model, property) => `Attempted to use an instruction result (probably use or tap) as computed source for ${model}.${property}. This is not possible.`
 });
-function ref(cb) {
-    return set(function ref(key) {
-        const refObjectFunction = this.setter(key, cb && createValueEffect(cb));
-        defineProperty(refObjectFunction, "current", {
-            set: refObjectFunction,
-            get: () => this.state[key]
-        });
-        return {
-            value: refObjectFunction
-        };
+function createRef(key, cb) {
+    const refObjectFunction = this.setter(key, cb && createValueEffect(cb));
+    defineProperty(refObjectFunction, "current", {
+        set: refObjectFunction,
+        get: () => this.state[key]
+    });
+    return refObjectFunction;
+}
+function ref(arg) {
+    return apply(function ref(key) {
+        let value = {};
+        if (typeof arg == "object") {
+            const source = manage(arg);
+            for (const key in source.state)
+                defineLazy(value, key, createRef.bind(source, key));
+        }
+        else
+            value = createRef.call(this, key, arg);
+        return { value };
     });
 }
 function on(initial, cb) {
-    return set(function on(key) {
+    return apply(function on(key) {
         this.manage(key, initial, cb && createValueEffect(cb));
     });
 }
 function memo(factory, defer) {
-    return set(function memo(key) {
+    return apply(function memo(key) {
         const source = this.subject;
         const get = () => factory.call(source);
         if (defer)
@@ -1015,7 +1019,7 @@ function memo(factory, defer) {
     });
 }
 function lazy(value) {
-    return set(function lazy(key) {
+    return apply(function lazy(key) {
         const source = this.subject;
         source[key] = value;
         defineProperty(this.state, key, {
@@ -1024,7 +1028,7 @@ function lazy(value) {
     });
 }
 function act(task) {
-    return set(function act(key) {
+    return apply(function act(key) {
         let pending = false;
         const invoke = (...args) => {
             if (pending)
@@ -1049,7 +1053,7 @@ function act(task) {
     });
 }
 function from(source, setter, getter) {
-    return set(function from(key) {
+    return apply(function from(key) {
         const { subject } = this;
         let getSource;
         // Easy mistake, using a peer, will always be unresolved.
@@ -1101,7 +1105,7 @@ function pending(source, compute) {
         });
 }
 function suspendForAsync(source) {
-    return set(function suspense(key) {
+    return apply(function suspense(key) {
         let waiting = true;
         let output;
         let error;
@@ -1170,9 +1174,9 @@ exports.Consumer = Consumer;
 exports.Model = Model;
 exports.Provider = Provider;
 exports.Singleton = Singleton;
-exports.State = State;
 exports.act = act;
-exports.attach = attach;
+exports.apply = apply;
+exports.child = child;
 exports["default"] = Model;
 exports.from = from;
 exports.lazy = lazy;
@@ -1181,6 +1185,5 @@ exports.on = on;
 exports.parent = parent;
 exports.pending = pending;
 exports.ref = ref;
-exports.set = set;
 exports.tap = tap;
 exports.use = use;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@expressive/mvc",
-  "version": "1.0.0-beta.20",
+  "version": "1.0.0-beta.21",
   "description": "Use classes to define state in React!",
   "author": {
     "name": "Gabe Klein",

package/types/index.d.ts

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

package/types/instructions.d.ts

@@ -5,7 +5,7 @@ import { Async, Class, InstanceOf, InterceptCallback } 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 apply <T = any> (instruction: Model.Instruction<T>, name?: string): T;
 
 /**
  * Creates a new child-instance of specified controller.
@@ -117,14 +117,24 @@ export function on <T = any> (initialValue: undefined, onUpdate: InterceptCallba
 export function on <T = any> (initialValue: T, onUpdate: InterceptCallback<T>): T;
 
 /**
- * Creates a ref-compatible property for use with components.
+ * Creates an object with references to all managed values.
+ * Each property will set value in state when invoked.
+ *
+ * *Properties are simultaneously a ref-function and ref-object, use as needed.*
+ *
+ * @param target - Source model from which to reference values.
+ */
+export function ref <T = Model> (target: T): { [P in Model.Fields<T>]: Model.Ref<T[P]> };
+
+/**
+ * Creates a ref-compatible property.
  * 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> (this: any, callback?: InterceptCallback<T>): Model.Ref<T>;
+export function ref <T = HTMLElement> (callback?: InterceptCallback<T>): Model.Ref<T>;
 
 /**
  * Sets an exotic method with managed ready-state. Property accepts an async function.
@@ -141,29 +151,29 @@ export function act <T extends Async> (action: T): T & { active: boolean };
 /**
  * Implement a computed value; output is returned by function from provided factory.
  *
- * @param fn - Factory function to generate a getter to subscribe dependancies.
+ * @param compute - Factory function to generate a getter to subscribe dependancies.
  */
-export function from <R> (fn: (property: string) => (this: any, state: any) => R): R;
+export function from <R> (compute: (property: string) => (this: any, state: any) => R): R;
 
 /**
  * Implement a computed value; output will be generated by provided function.
  *
  * @param source - Source Model to find and subscribe to, for input.
  * 
- * @param fn - Compute function. Bound to a subscriber-proxy of source, returns output value.
+ * @param compute - Compute function. Bound to a subscriber-proxy of source, returns output value.
  * Will update automatically as input values change.
  */
-export function from <T extends Class, R> (source: T, fn: (this: InstanceOf<T>, on: InstanceOf<T>) => R): R;
+export function from <T extends Class, R> (source: T, compute: (this: InstanceOf<T>, on: InstanceOf<T>) => R): R;
 
 /**
  * Implement a computed value; output will be generated by provided function.
  *
  * @param source - Source model from which computed value will be a subscriber.
  * 
- * @param fn - Compute function. Bound to a subscriber-proxy of source, returns output value.
+ * @param compute - Compute function. Bound to a subscriber-proxy of source, returns output value.
  * Will update automatically as input values change.
  */
-export function from <T, R> (source: T, fn: (this: T, on: T) => R): R;
+export function from <T, R> (source: T, compute: (this: T, on: T) => R): R;
 
 /**
  * Memoized value. Computes and stores a value returned by provided factory. 
@@ -190,13 +200,20 @@ export function pending (waitFor: () => Promise<void>): undefined;
 export function pending <T> (waitFor: () => Promise<T>): T;
 
 /**
- * Suspend for a computed value; output will be generated by provided function.
- * Will throw a promise if value is accessed while undefined, promise will
- * resolve once value gains any value.
+ * Suspend for a computed value, returned by syncronous function.
  *
- * @param source - Source model from which computed value will be a subscriber.
+ * If accessed while computing to undefined, will throw a promise. Function is subscribed
+ * and will re-evaluate anytime used properties change. Once function returns any value,
+ * outstanding promises resolve and are not thrown on subsequent access of this property.
  * 
- * @param fn - Compute function. Bound to a subscriber-proxy of source, returns output value.
- * Will update automatically as input values change.
+ * Similar to `from`, compute function will only run when inputs change and not upon access.
+ *
+ * This behavior is recursive. If return value _becomes_ undefined, property
+ * access will throw Promises again, awaiting its next value.
+ *
+ * @param source - Source object, from which computed value will be a subscriber.
+ *
+ * @param compute - Compute function returns output value. Bound to a subscriber of source.
+ * Will re-run automatically as input values change.
  */
- export function pending <T, R> (source: T, fn: (this: T, on: T) => R): Exclude<R, undefined>;
+ export function pending <T, R> (source: T, compute: (this: T, on: T) => R): Exclude<R, undefined>;

package/types/model.d.ts

@@ -153,7 +153,8 @@ declare const CONTROL: unique symbol;
 declare const LOCAL: unique symbol;
 declare const STATE: unique symbol;
 
-export abstract class State {
+export interface Model extends Lifecycle {}
+export abstract class Model {
     /** Controller for this instance. */
     [CONTROL]: Model.Controller;
 
@@ -280,6 +281,50 @@ export abstract class State {
 
     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>;
+    
+    // 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?: any): 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) => any): this;
 
     /** Use symbol to access controller of a model. */
     static CONTROL: typeof CONTROL;
@@ -387,61 +432,6 @@ export abstract class State {
     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?: any): 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) => any): this;
-
-
     /**
      * **React Hook** - Attach to instance of this controller within ambient component.
      * 
@@ -475,6 +465,13 @@ export abstract class Model extends State {
      * Documentation TBD.
      */
     static meta <T extends Class, K extends Model.SelectField<T>> (this: T, key?: K): ReturnType<K>;
+
+    /**
+     * 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 class Singleton extends Model {