@expressive/mvc 0.25.0 → 0.26.0

package/lib/index.d.ts

@@ -104,7 +104,7 @@ declare class Control<T extends {} = any> {
     observers: Map<string, Set<Observer<any>>>;
     constructor(subject: T, id?: string | number);
     add(key: Extract<keyof T, string>): void;
-    watch(key: keyof T & string, output: Control.PropertyDescriptor<any>): void;
+    watch(key: Extract<keyof T, string>, output: Control.PropertyDescriptor<any>): void;
     ref<K extends Model.Key<T>>(key: K, callback?: (this: T, value: T[K]) => boolean | void): (value: any) => void;
     update(key: string): void;
     addListener(fn: Observer): () => boolean;
@@ -374,25 +374,46 @@ declare function set<T>(factory: set.Factory<T> | Promise<T>, required?: boolean
 declare function set<T>(value: undefined, onUpdate: set.Callback<T>): T;
 declare function set<T>(value: T, onUpdate: set.Callback<T>): T;
 
+type Empty = Record<string, never>;
+declare namespace use {
+    type Key<T extends {}> = Extract<keyof T, string>;
+    /**
+     * Assign value to observable property.
+     *
+     * If property is not already observed, it will become so.
+     */
+    type SetValue<T extends {}> = <K extends Key<T>>(property: K, value: T[K]) => void;
+    /**
+     * Observe property for updates.
+     *
+     * If property is not already observed, it will become so.
+     */
+    type OnUpdate<T extends {}> = <K extends Key<T>>(property: K, callback: (value: T[K], key: K) => void) => () => void;
+    export type Observable<T extends {}> = T & {
+        set: SetValue<T>;
+        on: OnUpdate<T>;
+    };
+    export type Collection<T> = Observable<{
+        [key: string | number]: T;
+    }>;
+    export {};
+}
 /** Create a placeholder for specified Model type. */
 declare function use<T extends Model>(): T | undefined;
 /** Create a new child instance of model. */
-declare function use<T extends Model>(Type: Model.New<T>, callback?: (i: T) => void): T;
-/** Assign the result of a factory as a child model. */
-declare function use<T extends {}>(from: () => Promise<T> | T, required?: true): T;
-/** Assign the result of a factory as a child model. */
-declare function use<T extends {}>(from: () => Promise<T> | T, required: boolean): T | undefined;
-/** Create a managed child from factory function. */
-declare function use<T extends {}>(from: () => Promise<T> | T, callback?: (i: T) => void): T;
-declare function use<T extends {}>(data: T): T;
+declare function use<T extends Model>(Type: Model.New<T>, ready?: (i: T) => void): T;
 /**
-  * Create 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, however, if
-  * already active.
-  */
-declare function use<T extends Model>(peer: T, callback?: (i: T) => void): T;
+ * Use existing model as a child of model assigned to.
+ *
+ * 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, however, if
+ * already active.
+ **/
+declare function use<T extends Model>(model: T, ready?: (i: T) => void): T;
+/** Create a managed record with observable entries. */
+declare function use<T = any, C = use.Collection<T>>(record: Empty, ready?: (object: C) => void): C;
+/** Create a managed object with observable entries. */
+declare function use<T extends {}, O = use.Observable<T>>(data: T, ready?: (object: O) => void): O;
 
 export { Context, Control, Debug, Model, Model as default, get, ref, run, set, use };

package/lib/index.esm.js

@@ -42,25 +42,26 @@ function issues(register) {
 
 const { assign, create, defineProperties, defineProperty, entries, getPrototypeOf, getOwnPropertyDescriptor, getOwnPropertySymbols, values } = Object;
 
-const Oops$9 = issues({
+const Oops$8 = issues({
     NotReady: (model, key) => `Value ${model}.${key} value is not yet available.`,
     Destoryed: () => "Model is destroyed."
 });
 function suspense(source, key) {
-    const error = Oops$9.NotReady(source.subject, key);
+    const error = Oops$8.NotReady(source.subject, key);
+    const watch = source.observers.get(key);
     const promise = new Promise((resolve, reject) => {
-        const subs = source.observers.get(key);
-        const onUpdate = (key) => {
+        function onUpdate(key) {
             if (key)
                 return () => {
                     if (source.state[key] !== undefined) {
-                        subs.delete(onUpdate);
+                        watch.delete(onUpdate);
                         resolve();
                     }
                 };
-            reject(Oops$9.Destoryed());
-        };
-        subs.add(onUpdate);
+            if (key === null)
+                reject(Oops$8.Destoryed());
+        }
+        watch.add(onUpdate);
     });
     return assign(promise, {
         toString: () => String(error),
@@ -90,7 +91,7 @@ function mayRetry(fn) {
     return compute();
 }
 
-const Oops$8 = issues({
+const Oops$7 = issues({
     BadCallback: () => `Callback for effect-callback may only return a function.`
 });
 function createEffect(source, callback) {
@@ -108,7 +109,7 @@ function createEffect(source, callback) {
                 if (unSet instanceof Promise)
                     unSet = undefined;
                 if (unSet && typeof unSet !== "function")
-                    throw Oops$8.BadCallback();
+                    throw Oops$7.BadCallback();
             });
             if (output instanceof Promise) {
                 output.finally(() => busy = false);
@@ -136,11 +137,11 @@ function createValueEffect(callback) {
         if (typeof out == "function")
             unSet = out;
         else
-            throw Oops$8.BadCallback();
+            throw Oops$7.BadCallback();
     };
 }
 
-const Oops$7 = issues({
+const Oops$6 = issues({
     KeysExpected: (key) => `Key "${key}" was expected in current update.`
 });
 function addEventListener(source, select, callback, once) {
@@ -175,7 +176,7 @@ function awaitUpdate(source, select, timeout) {
             if (!self.frame.size)
                 resolve(false);
             else if (typeof select == "string" && !self.frame.has(select))
-                reject(Oops$7.KeysExpected(select));
+                reject(Oops$6.KeysExpected(select));
             else {
                 const remove = self.addListener(() => {
                     remove();
@@ -194,7 +195,7 @@ function awaitUpdate(source, select, timeout) {
     });
 }
 
-const Oops$6 = issues({
+const Oops$5 = issues({
     NotFound: (name) => `Could not find ${name} in context.`
 });
 function get$1(argument) {
@@ -209,7 +210,7 @@ function get$1(argument) {
                     ? Control.watch(got, k => k ? onUpdate : undefined)
                     : got;
             else if (argument !== false)
-                throw Oops$6.NotFound(this);
+                throw Oops$5.NotFound(this);
             return {
                 mount() {
                     onUpdate = refresh;
@@ -225,7 +226,7 @@ function get$1(argument) {
         let proxy;
         const found = context.get(this);
         if (!found)
-            throw Oops$6.NotFound(this);
+            throw Oops$5.NotFound(this);
         function forceUpdate(action) {
             if (typeof action == "function")
                 action = action();
@@ -418,13 +419,13 @@ defineProperty(Model, "toString", {
     }
 });
 
-const Oops$5 = issues({
+const Oops$4 = issues({
     BadAssignment: (parent, expected, got) => `${parent} expected Model of type ${expected} but got ${got}.`,
 });
-const INSTRUCTION = new Map();
-const PENDING$1 = new WeakMap();
 const REGISTER = new WeakMap();
 const OBSERVER = new WeakMap();
+const INSTRUCT = new Map();
+const PENDING$1 = new WeakMap();
 const PARENTS = new WeakMap();
 class Control {
     constructor(subject, id) {
@@ -439,9 +440,9 @@ class Control {
     }
     add(key) {
         const { value } = getOwnPropertyDescriptor(this.subject, key);
-        const instruction = INSTRUCTION.get(value);
+        const instruction = INSTRUCT.get(value);
         if (typeof instruction == "function") {
-            INSTRUCTION.delete(value);
+            INSTRUCT.delete(value);
             instruction(this, key);
         }
         else if (value instanceof Model)
@@ -578,7 +579,7 @@ function setRecursive(on, key, value) {
             control(next, true);
             return true;
         }
-        throw Oops$5.BadAssignment(`${on.subject}.${key}`, value.constructor, next);
+        throw Oops$4.BadAssignment(`${on.subject}.${key}`, value.constructor, next);
     };
     on.watch(key, { set });
     set(value);
@@ -596,7 +597,7 @@ function watch(on, cb) {
 }
 function apply(instruction) {
     const placeholder = Symbol("instruction");
-    INSTRUCTION.set(placeholder, (onto, key) => {
+    INSTRUCT.set(placeholder, (onto, key) => {
         delete onto.subject[key];
         const output = instruction.call(onto, key, onto);
         if (output)
@@ -609,7 +610,7 @@ function uid() {
     return (Math.random() * 0.722 + 0.278).toString(36).substring(2, 8).toUpperCase();
 }
 
-const Oops$4 = issues({
+const Oops$3 = issues({
     DuplicatePending: (key) => `Invoked action ${key} but one is already active.`
 });
 function run(task) {
@@ -617,7 +618,7 @@ function run(task) {
         let pending = false;
         const invoke = (...args) => __awaiter(this, void 0, void 0, function* () {
             if (pending)
-                return Promise.reject(Oops$4.DuplicatePending(key));
+                return Promise.reject(Oops$3.DuplicatePending(key));
             pending = true;
             control.update(key);
             try {
@@ -639,7 +640,7 @@ function run(task) {
     });
 }
 
-const Oops$3 = issues({
+const Oops$2 = issues({
     PeerNotAllowed: (model, property) => `Attempted to use an instruction result (probably use or get) as computed source for ${model}.${property}. This is not allowed.`,
     Failed: (parent, property, initial) => `An exception was thrown while ${initial ? "initializing" : "refreshing"} ${parent}.${property}.`,
     Required: (expects, child) => `New ${child} created standalone but requires parent of type ${expects}.`,
@@ -650,7 +651,7 @@ function get(arg0, arg1) {
     return apply((key, control) => {
         let { subject } = control;
         if (typeof arg0 == "symbol")
-            throw Oops$3.PeerNotAllowed(subject, key);
+            throw Oops$2.PeerNotAllowed(subject, key);
         let source = cb => cb(subject);
         if (arg0 instanceof Model)
             subject = arg0;
@@ -658,7 +659,7 @@ function get(arg0, arg1) {
             const hasParent = parent(subject);
             if (!hasParent) {
                 if (arg1 === true)
-                    throw Oops$3.Required(arg0, subject);
+                    throw Oops$2.Required(arg0, subject);
                 const fetch = Control.has(subject);
                 source = got => {
                     fetch(context => {
@@ -666,14 +667,14 @@ function get(arg0, arg1) {
                         if (model)
                             got(model);
                         else if (arg1 !== false)
-                            throw Oops$3.AmbientRequired(arg0, subject);
+                            throw Oops$2.AmbientRequired(arg0, subject);
                     });
                 };
             }
             else if (!arg0 || hasParent instanceof arg0)
                 subject = hasParent;
             else
-                throw Oops$3.Unexpected(arg0, subject, hasParent);
+                throw Oops$2.Unexpected(arg0, subject, hasParent);
         }
         else if (typeof arg0 == "function")
             arg1 = arg0.call(subject, key, subject);
@@ -716,7 +717,7 @@ function computed(parent, key, source, setter) {
             next = setter.call(proxy, proxy);
         }
         catch (err) {
-            Oops$3.Failed(parent.subject, key, initial).warn();
+            Oops$2.Failed(parent.subject, key, initial).warn();
             if (initial)
                 throw err;
             console.error(err);
@@ -804,7 +805,7 @@ function createRef(src, key, cb) {
     return refObjectFunction;
 }
 
-const Oops$2 = issues({
+const Oops$1 = issues({
     ComputeFailed: (model, key) => `Generating initial value for ${model}.${key} failed.`,
     NotReady: (model, key) => `Value ${model}.${key} value is not yet available.`
 });
@@ -812,150 +813,117 @@ function set(value, argument) {
     return apply((key, control) => {
         const { state, subject } = control;
         if (typeof value == "function" || value instanceof Promise) {
-            const required = argument !== false;
-            let getter;
+            const output = {};
             const init = () => {
                 try {
                     if (typeof value == "function")
                         value = mayRetry(value.bind(subject, key, subject));
-                    let pending;
-                    let error;
                     if (value instanceof Promise) {
-                        state[key] = undefined;
-                        pending = value
-                            .catch(err => error = err)
-                            .then(val => {
-                            state[key] = val;
-                            return val;
+                        const pending = value
+                            .then(value => {
+                            output.get = undefined;
+                            state[key] = value;
+                            return value;
+                        })
+                            .catch(err => {
+                            output.get = () => { throw err; };
                         })
                             .finally(() => {
-                            pending = undefined;
                             control.update(key);
                         });
+                        if (argument !== false)
+                            return () => {
+                                const { message, stack } = Oops$1.NotReady(subject, key);
+                                throw assign(pending, { message, stack });
+                            };
                     }
                     else
                         state[key] = value;
-                    const suspend = () => {
-                        if (required === false)
-                            return undefined;
-                        const issue = Oops$2.NotReady(subject, key);
-                        assign(pending, {
-                            message: issue.message,
-                            stack: issue.stack
-                        });
-                        throw pending;
-                    };
-                    getter = () => {
-                        if (error)
-                            throw error;
-                        if (pending)
-                            return suspend();
-                        return state[key];
-                    };
                 }
                 catch (err) {
-                    Oops$2.ComputeFailed(subject, key).warn();
+                    Oops$1.ComputeFailed(subject, key).warn();
                     throw err;
                 }
             };
-            if (argument === true)
+            if (argument)
                 init();
-            return () => {
-                if (!getter)
-                    init();
-                return getter();
-            };
+            else
+                output.get = () => {
+                    const get = output.get =
+                        key in state ? undefined : init();
+                    return get ? get() : state[key];
+                };
+            return output;
         }
-        let setter = typeof argument == "function"
+        const set = typeof argument == "function"
             ? createValueEffect(argument)
             : undefined;
-        if (value !== undefined)
+        if (value !== undefined) {
             state[key] = value;
-        else if (setter) {
-            const effect = setter;
-            setter = function (value) {
-                if (!(key in state))
-                    state[key] = undefined;
-                return effect.call(this, value);
-            };
+            return { set };
         }
-        return {
-            get: () => {
+        const output = {
+            get() {
                 if (key in state)
                     return state[key];
                 throw suspense(control, key);
-            },
-            set: setter
+            }
         };
+        if (set)
+            output.set = function (value) {
+                output.set = set;
+                state[key] = state[key];
+                return set.call(this, value);
+            };
+        return output;
     });
 }
 
-const Oops$1 = issues({
-    BadArgument: (type) => `Instruction \`use\` cannot accept argument type of ${type}.`,
-    NotReady: (model, key) => `Value ${model}.${key} value is not yet available.`
-});
 function use(input, argument) {
     return apply((key, source) => {
         const { state, subject } = source;
-        const required = argument !== false;
-        if (typeof input === "function") {
-            if ("prototype" in input && input === input.prototype.constructor)
-                input = new input();
-        }
-        else if (input && typeof input !== "object")
-            throw Oops$1.BadArgument(typeof input);
-        function init() {
-            const result = typeof input == "function" ?
-                mayRetry(() => input.call(subject, subject)) :
-                input;
-            if (result instanceof Promise) {
-                const pending = result
-                    .then(value => {
-                    output.get = undefined;
-                    set(value);
-                    return value;
-                })
-                    .catch(err => {
-                    output.get = () => { throw err; };
-                })
-                    .finally(() => {
-                    source.update(key);
-                });
-                if (required !== false)
-                    output.get = () => {
-                        throw assign(pending, Oops$1.NotReady(subject, key));
-                    };
-            }
-            else
-                set(result);
-        }
+        if (typeof input === "function")
+            input = new input();
         function set(next) {
             if (next instanceof Model) {
                 parent(next, subject);
                 control(next, true);
             }
-            else if (next) {
-                const control = new Control(create(next));
-                control.state = next;
-                for (const key in next)
-                    control.watch(key, {});
-                next = control.subject;
-            }
+            else if (next)
+                next = manage(next);
             state[key] = next;
             if (typeof argument == "function")
                 argument(next);
             return true;
         }
-        const output = { set };
-        if (required)
-            init();
-        else
-            output.get = () => {
-                init();
-                return state[key];
-            };
-        return output;
+        set(input);
+        return { set };
     });
+}
+function manage(next) {
+    const methods = {
+        on(key, callback) {
+            if (!(key in next))
+                control.watch(key, { value: subject[key] });
+            return control.addListener(k => {
+                if (k === key)
+                    return () => callback(next[key], key);
+                if (typeof k !== "string")
+                    return k;
+            });
+        },
+        set(key, value) {
+            if (key in next)
+                subject[key] = value;
+            else
+                control.watch(key, { value });
+        }
+    };
+    const subject = assign(create(next), methods);
+    const control = new Control(subject);
+    for (const key in control.state = next)
+        control.watch(key, {});
+    return subject;
 }
 
 const Oops = issues({

package/lib/index.js

@@ -46,25 +46,26 @@ function issues(register) {
 
 const { assign, create, defineProperties, defineProperty, entries, getPrototypeOf, getOwnPropertyDescriptor, getOwnPropertySymbols, values } = Object;
 
-const Oops$9 = issues({
+const Oops$8 = issues({
     NotReady: (model, key) => `Value ${model}.${key} value is not yet available.`,
     Destoryed: () => "Model is destroyed."
 });
 function suspense(source, key) {
-    const error = Oops$9.NotReady(source.subject, key);
+    const error = Oops$8.NotReady(source.subject, key);
+    const watch = source.observers.get(key);
     const promise = new Promise((resolve, reject) => {
-        const subs = source.observers.get(key);
-        const onUpdate = (key) => {
+        function onUpdate(key) {
             if (key)
                 return () => {
                     if (source.state[key] !== undefined) {
-                        subs.delete(onUpdate);
+                        watch.delete(onUpdate);
                         resolve();
                     }
                 };
-            reject(Oops$9.Destoryed());
-        };
-        subs.add(onUpdate);
+            if (key === null)
+                reject(Oops$8.Destoryed());
+        }
+        watch.add(onUpdate);
     });
     return assign(promise, {
         toString: () => String(error),
@@ -94,7 +95,7 @@ function mayRetry(fn) {
     return compute();
 }
 
-const Oops$8 = issues({
+const Oops$7 = issues({
     BadCallback: () => `Callback for effect-callback may only return a function.`
 });
 function createEffect(source, callback) {
@@ -112,7 +113,7 @@ function createEffect(source, callback) {
                 if (unSet instanceof Promise)
                     unSet = undefined;
                 if (unSet && typeof unSet !== "function")
-                    throw Oops$8.BadCallback();
+                    throw Oops$7.BadCallback();
             });
             if (output instanceof Promise) {
                 output.finally(() => busy = false);
@@ -140,11 +141,11 @@ function createValueEffect(callback) {
         if (typeof out == "function")
             unSet = out;
         else
-            throw Oops$8.BadCallback();
+            throw Oops$7.BadCallback();
     };
 }
 
-const Oops$7 = issues({
+const Oops$6 = issues({
     KeysExpected: (key) => `Key "${key}" was expected in current update.`
 });
 function addEventListener(source, select, callback, once) {
@@ -179,7 +180,7 @@ function awaitUpdate(source, select, timeout) {
             if (!self.frame.size)
                 resolve(false);
             else if (typeof select == "string" && !self.frame.has(select))
-                reject(Oops$7.KeysExpected(select));
+                reject(Oops$6.KeysExpected(select));
             else {
                 const remove = self.addListener(() => {
                     remove();
@@ -198,7 +199,7 @@ function awaitUpdate(source, select, timeout) {
     });
 }
 
-const Oops$6 = issues({
+const Oops$5 = issues({
     NotFound: (name) => `Could not find ${name} in context.`
 });
 function get$1(argument) {
@@ -213,7 +214,7 @@ function get$1(argument) {
                     ? Control.watch(got, k => k ? onUpdate : undefined)
                     : got;
             else if (argument !== false)
-                throw Oops$6.NotFound(this);
+                throw Oops$5.NotFound(this);
             return {
                 mount() {
                     onUpdate = refresh;
@@ -229,7 +230,7 @@ function get$1(argument) {
         let proxy;
         const found = context.get(this);
         if (!found)
-            throw Oops$6.NotFound(this);
+            throw Oops$5.NotFound(this);
         function forceUpdate(action) {
             if (typeof action == "function")
                 action = action();
@@ -422,13 +423,13 @@ defineProperty(Model, "toString", {
     }
 });
 
-const Oops$5 = issues({
+const Oops$4 = issues({
     BadAssignment: (parent, expected, got) => `${parent} expected Model of type ${expected} but got ${got}.`,
 });
-const INSTRUCTION = new Map();
-const PENDING$1 = new WeakMap();
 const REGISTER = new WeakMap();
 const OBSERVER = new WeakMap();
+const INSTRUCT = new Map();
+const PENDING$1 = new WeakMap();
 const PARENTS = new WeakMap();
 class Control {
     constructor(subject, id) {
@@ -443,9 +444,9 @@ class Control {
     }
     add(key) {
         const { value } = getOwnPropertyDescriptor(this.subject, key);
-        const instruction = INSTRUCTION.get(value);
+        const instruction = INSTRUCT.get(value);
         if (typeof instruction == "function") {
-            INSTRUCTION.delete(value);
+            INSTRUCT.delete(value);
             instruction(this, key);
         }
         else if (value instanceof Model)
@@ -582,7 +583,7 @@ function setRecursive(on, key, value) {
             control(next, true);
             return true;
         }
-        throw Oops$5.BadAssignment(`${on.subject}.${key}`, value.constructor, next);
+        throw Oops$4.BadAssignment(`${on.subject}.${key}`, value.constructor, next);
     };
     on.watch(key, { set });
     set(value);
@@ -600,7 +601,7 @@ function watch(on, cb) {
 }
 function apply(instruction) {
     const placeholder = Symbol("instruction");
-    INSTRUCTION.set(placeholder, (onto, key) => {
+    INSTRUCT.set(placeholder, (onto, key) => {
         delete onto.subject[key];
         const output = instruction.call(onto, key, onto);
         if (output)
@@ -613,7 +614,7 @@ function uid() {
     return (Math.random() * 0.722 + 0.278).toString(36).substring(2, 8).toUpperCase();
 }
 
-const Oops$4 = issues({
+const Oops$3 = issues({
     DuplicatePending: (key) => `Invoked action ${key} but one is already active.`
 });
 function run(task) {
@@ -621,7 +622,7 @@ function run(task) {
         let pending = false;
         const invoke = (...args) => __awaiter(this, void 0, void 0, function* () {
             if (pending)
-                return Promise.reject(Oops$4.DuplicatePending(key));
+                return Promise.reject(Oops$3.DuplicatePending(key));
             pending = true;
             control.update(key);
             try {
@@ -643,7 +644,7 @@ function run(task) {
     });
 }
 
-const Oops$3 = issues({
+const Oops$2 = issues({
     PeerNotAllowed: (model, property) => `Attempted to use an instruction result (probably use or get) as computed source for ${model}.${property}. This is not allowed.`,
     Failed: (parent, property, initial) => `An exception was thrown while ${initial ? "initializing" : "refreshing"} ${parent}.${property}.`,
     Required: (expects, child) => `New ${child} created standalone but requires parent of type ${expects}.`,
@@ -654,7 +655,7 @@ function get(arg0, arg1) {
     return apply((key, control) => {
         let { subject } = control;
         if (typeof arg0 == "symbol")
-            throw Oops$3.PeerNotAllowed(subject, key);
+            throw Oops$2.PeerNotAllowed(subject, key);
         let source = cb => cb(subject);
         if (arg0 instanceof Model)
             subject = arg0;
@@ -662,7 +663,7 @@ function get(arg0, arg1) {
             const hasParent = parent(subject);
             if (!hasParent) {
                 if (arg1 === true)
-                    throw Oops$3.Required(arg0, subject);
+                    throw Oops$2.Required(arg0, subject);
                 const fetch = Control.has(subject);
                 source = got => {
                     fetch(context => {
@@ -670,14 +671,14 @@ function get(arg0, arg1) {
                         if (model)
                             got(model);
                         else if (arg1 !== false)
-                            throw Oops$3.AmbientRequired(arg0, subject);
+                            throw Oops$2.AmbientRequired(arg0, subject);
                     });
                 };
             }
             else if (!arg0 || hasParent instanceof arg0)
                 subject = hasParent;
             else
-                throw Oops$3.Unexpected(arg0, subject, hasParent);
+                throw Oops$2.Unexpected(arg0, subject, hasParent);
         }
         else if (typeof arg0 == "function")
             arg1 = arg0.call(subject, key, subject);
@@ -720,7 +721,7 @@ function computed(parent, key, source, setter) {
             next = setter.call(proxy, proxy);
         }
         catch (err) {
-            Oops$3.Failed(parent.subject, key, initial).warn();
+            Oops$2.Failed(parent.subject, key, initial).warn();
             if (initial)
                 throw err;
             console.error(err);
@@ -808,7 +809,7 @@ function createRef(src, key, cb) {
     return refObjectFunction;
 }
 
-const Oops$2 = issues({
+const Oops$1 = issues({
     ComputeFailed: (model, key) => `Generating initial value for ${model}.${key} failed.`,
     NotReady: (model, key) => `Value ${model}.${key} value is not yet available.`
 });
@@ -816,150 +817,117 @@ function set(value, argument) {
     return apply((key, control) => {
         const { state, subject } = control;
         if (typeof value == "function" || value instanceof Promise) {
-            const required = argument !== false;
-            let getter;
+            const output = {};
             const init = () => {
                 try {
                     if (typeof value == "function")
                         value = mayRetry(value.bind(subject, key, subject));
-                    let pending;
-                    let error;
                     if (value instanceof Promise) {
-                        state[key] = undefined;
-                        pending = value
-                            .catch(err => error = err)
-                            .then(val => {
-                            state[key] = val;
-                            return val;
+                        const pending = value
+                            .then(value => {
+                            output.get = undefined;
+                            state[key] = value;
+                            return value;
+                        })
+                            .catch(err => {
+                            output.get = () => { throw err; };
                         })
                             .finally(() => {
-                            pending = undefined;
                             control.update(key);
                         });
+                        if (argument !== false)
+                            return () => {
+                                const { message, stack } = Oops$1.NotReady(subject, key);
+                                throw assign(pending, { message, stack });
+                            };
                     }
                     else
                         state[key] = value;
-                    const suspend = () => {
-                        if (required === false)
-                            return undefined;
-                        const issue = Oops$2.NotReady(subject, key);
-                        assign(pending, {
-                            message: issue.message,
-                            stack: issue.stack
-                        });
-                        throw pending;
-                    };
-                    getter = () => {
-                        if (error)
-                            throw error;
-                        if (pending)
-                            return suspend();
-                        return state[key];
-                    };
                 }
                 catch (err) {
-                    Oops$2.ComputeFailed(subject, key).warn();
+                    Oops$1.ComputeFailed(subject, key).warn();
                     throw err;
                 }
             };
-            if (argument === true)
+            if (argument)
                 init();
-            return () => {
-                if (!getter)
-                    init();
-                return getter();
-            };
+            else
+                output.get = () => {
+                    const get = output.get =
+                        key in state ? undefined : init();
+                    return get ? get() : state[key];
+                };
+            return output;
         }
-        let setter = typeof argument == "function"
+        const set = typeof argument == "function"
             ? createValueEffect(argument)
             : undefined;
-        if (value !== undefined)
+        if (value !== undefined) {
             state[key] = value;
-        else if (setter) {
-            const effect = setter;
-            setter = function (value) {
-                if (!(key in state))
-                    state[key] = undefined;
-                return effect.call(this, value);
-            };
+            return { set };
         }
-        return {
-            get: () => {
+        const output = {
+            get() {
                 if (key in state)
                     return state[key];
                 throw suspense(control, key);
-            },
-            set: setter
+            }
         };
+        if (set)
+            output.set = function (value) {
+                output.set = set;
+                state[key] = state[key];
+                return set.call(this, value);
+            };
+        return output;
     });
 }
 
-const Oops$1 = issues({
-    BadArgument: (type) => `Instruction \`use\` cannot accept argument type of ${type}.`,
-    NotReady: (model, key) => `Value ${model}.${key} value is not yet available.`
-});
 function use(input, argument) {
     return apply((key, source) => {
         const { state, subject } = source;
-        const required = argument !== false;
-        if (typeof input === "function") {
-            if ("prototype" in input && input === input.prototype.constructor)
-                input = new input();
-        }
-        else if (input && typeof input !== "object")
-            throw Oops$1.BadArgument(typeof input);
-        function init() {
-            const result = typeof input == "function" ?
-                mayRetry(() => input.call(subject, subject)) :
-                input;
-            if (result instanceof Promise) {
-                const pending = result
-                    .then(value => {
-                    output.get = undefined;
-                    set(value);
-                    return value;
-                })
-                    .catch(err => {
-                    output.get = () => { throw err; };
-                })
-                    .finally(() => {
-                    source.update(key);
-                });
-                if (required !== false)
-                    output.get = () => {
-                        throw assign(pending, Oops$1.NotReady(subject, key));
-                    };
-            }
-            else
-                set(result);
-        }
+        if (typeof input === "function")
+            input = new input();
         function set(next) {
             if (next instanceof Model) {
                 parent(next, subject);
                 control(next, true);
             }
-            else if (next) {
-                const control = new Control(create(next));
-                control.state = next;
-                for (const key in next)
-                    control.watch(key, {});
-                next = control.subject;
-            }
+            else if (next)
+                next = manage(next);
             state[key] = next;
             if (typeof argument == "function")
                 argument(next);
             return true;
         }
-        const output = { set };
-        if (required)
-            init();
-        else
-            output.get = () => {
-                init();
-                return state[key];
-            };
-        return output;
+        set(input);
+        return { set };
     });
+}
+function manage(next) {
+    const methods = {
+        on(key, callback) {
+            if (!(key in next))
+                control.watch(key, { value: subject[key] });
+            return control.addListener(k => {
+                if (k === key)
+                    return () => callback(next[key], key);
+                if (typeof k !== "string")
+                    return k;
+            });
+        },
+        set(key, value) {
+            if (key in next)
+                subject[key] = value;
+            else
+                control.watch(key, { value });
+        }
+    };
+    const subject = assign(create(next), methods);
+    const control = new Control(subject);
+    for (const key in control.state = next)
+        control.watch(key, {});
+    return subject;
 }
 
 const Oops = issues({

package/package.json

@@ -26,6 +26,6 @@
     "prebuild": "rm -rf lib/",
     "preversion": "npm run test && npm run build"
   },
-  "version": "0.25.0",
-  "gitHead": "a7c707bf59325bd4bf1388e061f7991acb726a13"
+  "version": "0.26.0",
+  "gitHead": "195aa8bd3fe81efd5f15a5a188854ab35e211fb9"
 }