@expressive/mvc 0.0.4 → 0.2.0

package/lib/index.d.ts

@@ -75,6 +75,11 @@ declare namespace Model {
     export type Methods<T> = {
         [K in keyof T]: T[K] extends Ref ? never : T[K] extends Function ? K : never;
     }[keyof T];
+    export type Refs<T extends Model> = {
+        <K extends Field<T>>(key: K, value: T[K]): void;
+    } & {
+        [P in Field<T>]: (next: any) => void;
+    };
     /**
      * Subset of `keyof T` which are not methods or defined by base Model U.
      *
@@ -107,14 +112,23 @@ interface Model extends Stateful {
      * Circular reference to `this` controller.
      *
      * Useful to obtain full reference where one has already destructured.
+     *
+     * @deprecated will be removed in favor of `is`
      */
     get: this;
     /**
-    * Circular reference to `this` controller.
+     * Circular reference to `this` controller.
+     *
+     * Useful to obtain full reference where one has already destructured.
+     */
+    is: this;
+    /**
+    * Setter utility
     *
-    * Shortcut is mainly to update values, while having destructured already.
+    * Can be used to set (and force-update) values.
+    * Shortcut to update values, contains refs for all controlled values.
     */
-    set: this;
+    set: Model.Refs<this>;
 }
 declare class Model {
     static [CONTROL]: Controller;
@@ -186,7 +200,7 @@ declare class Controller<T extends Stateful = any> {
     constructor(subject: T);
     start(): void;
     stop(): void;
-    private manage;
+    manage(key: Model.Field<T>, value: any): void;
     ref(key: Model.Field<T>, handler?: Controller.OnValue<T>): (value: any) => void;
     addListener(listener: Controller.OnEvent<T>): () => void;
     emit(keys: readonly Model.Event<T>[]): void;
@@ -458,8 +472,10 @@ declare class MVC extends Model {
 
 declare namespace Consumer {
     type HasProps<E extends Class> = {
+        /** @deprecated - use for instead */
+        of?: never;
         /** Type of controller to fetch from context. */
-        of: E;
+        for: E;
         /**
          * Getter function. Is called on every natural render of this component.
          * Will throw if usable instance cannot be found in context.
@@ -467,14 +483,18 @@ declare namespace Consumer {
         has: (value: InstanceType<E>) => void;
     };
     type GetProps<E extends Class> = {
+        /** @deprecated - use for instead */
+        of?: never;
         /** Type of controller to fetch from context. */
-        of: E;
+        for: E;
         /** Getter function. Is called on every natural render of this component. */
         get: (value: InstanceType<E> | undefined) => void;
     };
     type RenderProps<E extends Class> = {
+        /** @deprecated - use for instead */
+        of?: never;
         /** Type of controller to fetch from context. */
-        of: E;
+        for: E;
         /**
          * Render function, will receive instance of desired controller.
          *
@@ -507,11 +527,15 @@ declare namespace Provider {
     };
     type Existent<E> = E extends Class ? InstanceType<E> : E extends Model ? E : never;
     type NormalProps<E, I = Existent<E>> = {
-        of: E;
+        /** @deprecated use for instead. */
+        of?: never;
+        for: E;
         children: React.ReactNode | ((instance: I) => React.ReactNode);
     } & Model.Compat<I>;
     type MultipleProps<T extends Item> = {
-        of: Collection<T>;
+        /** @deprecated use for instead. */
+        of?: never;
+        for: Collection<T>;
         children?: React.ReactNode | (() => React.ReactNode);
     } & Model.Compat<Existent<T>>;
     type Props<T extends Item> = MultipleProps<T> | NormalProps<T>;
@@ -575,7 +599,7 @@ declare function tap<T extends Class>(Type: T, required?: boolean): InstanceOf<T
 declare function useFrom<T extends Stateful, R>(source: (() => T) | T, compute: (this: T, from: T) => R, expect: true): Exclude<R, undefined>;
 declare function useFrom<T extends Stateful, R>(source: (() => T) | T, compute: (this: T, from: T) => R, expect?: boolean): R;
 
-declare function useInContext<T extends typeof Model>(Type: T, arg?: boolean | string): any;
+declare function useLocal<T extends typeof Model>(Type: T, arg?: boolean | string): any;
 
 declare function useModel<T extends Class, I extends InstanceOf<T>>(source: T, watch: Model.Field<I>[], callback?: (instance: I) => void): I;
 declare function useModel<T extends Class, I extends InstanceOf<T>>(source: T, callback?: (instance: I) => void): I;
@@ -597,4 +621,4 @@ declare function useTap<T extends Stateful, K extends Model.Field<T>>(source: T
 declare function useTap<T extends Stateful, R>(source: T | (() => T) | useTap.Tappable, compute: (this: T, from: T) => R, expect: true): Exclude<R, undefined>;
 declare function useTap<T extends Stateful, R>(source: T | (() => T) | useTap.Tappable, compute: (this: T, from: T) => R, expect?: boolean): R;
 
-export { CONTROL, Consumer, Global, LOCAL, MVC as Model, Provider, STATE, Stateful, WHY, act, apply, array, MVC as default, from, parent, ref, set, tap, use, useFrom, useInContext, useModel, useTap };
+export { CONTROL, Consumer, Global, LOCAL, MVC as Model, Provider, STATE, Stateful, WHY, act, apply, array, MVC as default, from, parent, ref, set, tap, use, useFrom, useLocal, useModel, useTap };

package/lib/index.esm.js

@@ -43,10 +43,10 @@ function issues(register) {
 }
 
 const Oops$c = issues({
-    ValueNotReady: (model, key) => `Value ${model}.${key} value is not yet available.`,
+    NotReady: (model, key) => `Value ${model}.${key} value is not yet available.`,
 });
 function suspend(source, key) {
-    const error = Oops$c.ValueNotReady(source.subject, key);
+    const error = Oops$c.NotReady(source.subject, key);
     const promise = new Promise(resolve => {
         const release = source.addListener(forKey => {
             if (forKey == key)
@@ -87,7 +87,7 @@ function mayRetry(fn) {
 }
 
 const Oops$b = issues({
-    BadEffectCallback: () => `Callback for effect-callback may only return a function.`
+    BadCallback: () => `Callback for effect-callback may only return a function.`
 });
 const { assign, create, defineProperty, entries, getPrototypeOf, getOwnPropertyNames, getOwnPropertyDescriptor, getOwnPropertySymbols, values } = Object;
 function define(target, key, value) {
@@ -112,7 +112,7 @@ function createEffect(callback) {
         if (unSet instanceof Promise)
             unSet = undefined;
         if (unSet && typeof unSet !== "function")
-            throw Oops$b.BadEffectCallback();
+            throw Oops$b.BadCallback();
     };
 }
 function createValueEffect(callback) {
@@ -128,7 +128,7 @@ function createValueEffect(callback) {
         if (typeof out == "function")
             unSet = out;
         else
-            throw Oops$b.BadEffectCallback();
+            throw Oops$b.BadCallback();
     };
 }
 
@@ -150,7 +150,16 @@ class Model {
     constructor() {
         define(this, CONTROL, new Controller(this));
         define(this, "get", this);
-        define(this, "set", this);
+        define(this, "is", this);
+        defineLazy(this, "set", () => {
+            const controller = control(this);
+            const assign = (key, value) => {
+                controller.update(key, value);
+            };
+            for (const key of getOwnPropertyNames(controller.proxy))
+                define(assign, key, controller.ref(key));
+            return assign;
+        });
     }
     get [STATE]() {
         return this[CONTROL].state;
@@ -287,10 +296,7 @@ class Model {
         return (typeof maybe == "function" &&
             maybe.prototype instanceof this);
     }
-}
-defineLazy(Model, CONTROL, function () {
-    return new Controller(this);
-});
+}
 
 class Subscriber {
     constructor(target, onUpdate) {
@@ -339,10 +345,10 @@ class Subscriber {
 }
 
 const Oops$a = issues({
-    BadComputedSource: (model, property, got) => `Bad from-instruction provided to ${model}.${property}. Expects an arrow-function or a Model as source. Got ${got}.`,
+    BadSource: (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.`,
-    ComputeFailed: (parent, property, initial) => `An exception was thrown while ${initial ? "initializing" : "refreshing"} [${parent}.${property}].`,
-    ComputedEarly: (property) => `Note: Computed values don't run until accessed, except when subscribed to. '${property}' getter may have run earlier than intended.`
+    Failed: (parent, property, initial) => `An exception was thrown while ${initial ? "initializing" : "refreshing"} [${parent}.${property}].`,
+    Early: (property) => `Note: Computed values don't run until accessed, except when subscribed to. '${property}' getter may have run earlier than intended.`
 });
 const INIT = new WeakSet();
 const INFO = new WeakMap();
@@ -369,7 +375,7 @@ function from(source, arg1, arg2) {
         }
         // Regular function is too ambiguous so not allowed.
         else
-            throw Oops$a.BadComputedSource(subject, key, source);
+            throw Oops$a.BadSource(subject, key, source);
         let sub;
         const setter = arg1;
         const info = { key, parent, priority: 1 };
@@ -384,7 +390,7 @@ function from(source, arg1, arg2) {
                 return setter.call(sub.proxy, sub.proxy);
             }
             catch (err) {
-                Oops$a.ComputeFailed(subject, key, !!initial).warn();
+                Oops$a.Failed(subject, key, !!initial).warn();
                 throw err;
             }
         }
@@ -425,7 +431,7 @@ function from(source, arg1, arg2) {
             }
             catch (e) {
                 if (early)
-                    Oops$a.ComputedEarly(key).warn();
+                    Oops$a.Early(key).warn();
                 throw e;
             }
             finally {
@@ -492,26 +498,28 @@ class Controller {
         this.proxy = Object.create(subject);
     }
     start() {
-        for (const key in this.subject)
-            this.manage(key);
+        READY.add(this);
+        for (const key in this.subject) {
+            const { value: entry } = getOwnPropertyDescriptor(this.subject, key);
+            if (typeof entry == "function")
+                continue;
+            if (typeof entry == "symbol") {
+                const instruction = PENDING.get(entry);
+                if (instruction)
+                    instruction.call(this, key, this);
+                continue;
+            }
+            this.manage(key, entry);
+        }
         this.emit([]);
     }
     stop() {
         this.followers.clear();
         this.onDestroy.forEach(x => x());
     }
-    manage(key) {
+    manage(key, value) {
         const { proxy, state, subject } = this;
-        const { value: entry } = getOwnPropertyDescriptor(subject, key);
-        if (typeof entry == "function")
-            return;
-        if (typeof entry == "symbol") {
-            const instruction = PENDING.get(entry);
-            if (instruction)
-                instruction.call(this, key, this);
-            return;
-        }
-        state[key] = entry;
+        state[key] = value;
         const set = this.ref(key);
         defineProperty(subject, key, {
             enumerable: false,
@@ -603,26 +611,20 @@ class Controller {
 }
 function control(subject, cb) {
     let control = subject[CONTROL];
-    const ready = READY.has(control);
     if (!control) {
         control = new Controller(subject);
         define(subject, CONTROL, control);
     }
-    if (!cb) {
-        if (!ready) {
-            READY.add(control);
-            control.start();
-        }
-        return control;
-    }
+    const ready = READY.has(control);
     if (!ready) {
-        let done;
-        control.requestUpdate(() => {
-            done = cb(control);
-        });
-        return () => done && done();
+        if (cb) {
+            let done;
+            control.requestUpdate(() => done = cb(control));
+            return () => done && done();
+        }
+        control.start();
     }
-    return cb(control);
+    return cb ? cb(control) : control;
 }
 
 function apply(fn, label) {
@@ -710,14 +712,14 @@ function forSubscriber(fn) {
 }
 
 const Oops$8 = issues({
-    DuplicateAction: (key) => `Invoked action ${key} but one is already active.`
+    DuplicatePending: (key) => `Invoked action ${key} but one is already active.`
 });
 function act(task) {
     return apply(function act(key) {
         let pending = false;
         const invoke = (...args) => __awaiter(this, void 0, void 0, function* () {
             if (pending)
-                return Promise.reject(Oops$8.DuplicateAction(key));
+                return Promise.reject(Oops$8.DuplicatePending(key));
             pending = true;
             this.update(key);
             try {
@@ -823,8 +825,8 @@ function createRef(key, cb) {
 const Oops$7 = issues({
     NonOptional: (Parent, key) => `Property ${Parent}.${key} is marked as required.`,
     BadFactory: () => `Set instruction can only accept a factory or undefined.`,
-    ValueNotReady: (model, key) => `Value ${model}.${key} value is not yet available.`,
-    FactoryFailed: (model, key) => `Generating initial value for ${model}.${key} failed.`
+    NotReady: (model, key) => `Value ${model}.${key} value is not yet available.`,
+    Failed: (model, key) => `Generating initial value for ${model}.${key} failed.`
 });
 function set(factory, argument) {
     return apply(function set(key) {
@@ -875,7 +877,7 @@ function pendingFactory(parent, key, fn, required) {
     const suspend = () => {
         if (required === false)
             return undefined;
-        const issue = Oops$7.ValueNotReady(subject, key);
+        const issue = Oops$7.NotReady(subject, key);
         Object.assign(pending, {
             message: issue.message,
             stack: issue.stack
@@ -887,7 +889,7 @@ function pendingFactory(parent, key, fn, required) {
             init();
         }
         catch (err) {
-            Oops$7.FactoryFailed(subject, key).warn();
+            Oops$7.Failed(subject, key).warn();
             throw err;
         }
     return () => {
@@ -906,8 +908,8 @@ function pendingFactory(parent, key, fn, required) {
 
 const Parent = new WeakMap();
 const Oops$6 = issues({
-    ParentRequired: (expects, child) => `New ${child} created standalone but requires parent of type ${expects}. Did you remember to create via use(${child})?`,
-    UnexpectedParent: (expects, child, got) => `New ${child} created as child of ${got}, but must be instanceof ${expects}.`,
+    Required: (expects, child) => `New ${child} created standalone but requires parent of type ${expects}. Did you remember to create via use(${child})?`,
+    Unexpected: (expects, child, got) => `New ${child} created as child of ${got}, but must be instanceof ${expects}.`,
 });
 function parent(Expects, required) {
     return apply(function parent() {
@@ -916,10 +918,10 @@ function parent(Expects, required) {
         const expected = Expects.name;
         if (!value) {
             if (required !== false)
-                throw Oops$6.ParentRequired(expected, child);
+                throw Oops$6.Required(expected, child);
         }
         else if (!(value instanceof Expects))
-            throw Oops$6.UnexpectedParent(expected, child, value);
+            throw Oops$6.Unexpected(expected, child, value);
         return { value };
     });
 }
@@ -1024,19 +1026,19 @@ class Lookup {
 const LookupContext = React.createContext(new Lookup());
 const useLookup = () => React.useContext(LookupContext);
 const Oops$4 = issues({
-    NothingInContext: (name) => `Couldn't find ${name} in context; did you forget to use a Provider?`
+    NotFound: (name) => `Couldn't find ${name} in context; did you forget to use a Provider?`
 });
-function useInContext(Type, arg) {
+function useLocal(Type, arg) {
     const instance = useLookup().get(Type);
     if (!instance && arg !== false)
-        throw Oops$4.NothingInContext(Type.name);
+        throw Oops$4.NotFound(Type.name);
     return typeof arg == "string" ?
         instance[arg] :
         instance;
 }
 
 const Oops$3 = issues({
-    CantAttachGlobal: (parent, child) => `Global '${parent}' attempted to attach '${child}' but it is not also a singleton.`,
+    NotAllowed: (parent, child) => `Global '${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();
@@ -1050,7 +1052,7 @@ function tap(type, argument) {
             };
         const { subject } = this;
         if ("set" in subject.constructor)
-            throw Oops$3.CantAttachGlobal(subject, type.name);
+            throw Oops$3.NotAllowed(subject, type.name);
         getPending(subject).push(context => {
             let instance = context.get(type);
             if (typeof argument == "function") {
@@ -1194,7 +1196,7 @@ function useTap(source, path, expect) {
         if ("get" in source)
             return () => source.get();
         if ("prototype" in source)
-            return () => useInContext(source);
+            return () => useLocal(source);
         else
             return source;
     }, [])();
@@ -1229,7 +1231,7 @@ class MVC extends Model {
         return useModel(this, arg, callback);
     }
     static get(required) {
-        return useInContext(this, required);
+        return useLocal(this, required);
     }
     static tap(key, expect) {
         return useTap(this, key, expect);
@@ -1275,25 +1277,28 @@ class MVC extends Model {
 }
 
 const Oops$2 = issues({
-    BadConsumerProps: () => `Provider expects either a render function, 'get' or 'has' props.`
+    BadProps: () => `Provider expects either a render function, 'get' or 'has' props.`
 });
 function Consumer(props) {
-    const { get, has, children, of: Control } = props;
+    const { get, has, children, for: type } = props;
     if (typeof children == "function")
-        return children(useTap(Control));
+        return children(useTap(type));
     const callback = has || get;
     if (typeof callback == "function")
-        callback(useInContext(Control, !!has));
+        callback(useLocal(type, !!has));
     else
-        throw Oops$2.BadConsumerProps();
+        throw Oops$2.BadProps();
     return null;
 }
 
 const Oops$1 = issues({
-    NoProviderType: () => `Provider 'of' prop must be Model, typeof Model or a collection of them.`
+    NoType: () => "Provider 'of' prop must be Model, typeof Model or a collection of them.",
+    PropDeprecated: () => "Provider `of` prop is deprecated, use `for` instead."
 });
 function Provider(props) {
-    const context = useNewContext(props.of);
+    if ("of" in props)
+        throw Oops$1.PropDeprecated();
+    const context = useNewContext(props.for);
     const render = props.children;
     useAppliedProps(context, props);
     React.useLayoutEffect(() => () => context.pop(), []);
@@ -1305,7 +1310,7 @@ function useNewContext(inject) {
     const from = useLookup();
     return React.useMemo(() => {
         if (!inject)
-            throw Oops$1.NoProviderType();
+            throw Oops$1.NoType();
         const context = from.push(inject);
         for (const instance of context.local)
             if (instance)
@@ -1319,7 +1324,7 @@ function useAppliedProps(within, props) {
         const targets = within.local;
         return function integrate(props) {
             for (const [key, value] of entries(props))
-                if (key != "of" && key != "children")
+                if (["of", "for", "children"].indexOf(key) < 0)
                     for (const into of targets)
                         if (into && key in into)
                             into[key] = value;
@@ -1340,15 +1345,15 @@ function RenderFunction(props) {
 }
 
 const Oops = issues({
-    GlobalDoesNotExist: (name) => `Tried to access singleton ${name}, but none exist! Did you forget to initialize?\nCall ${name}.create() before attempting to access, or consider using ${name}.use() instead.`,
-    GlobalExists: (name) => `Shared instance of ${name} already exists! Consider unmounting existing, or use ${name}.reset() to force-delete it.`
+    DoesNotExist: (name) => `Tried to access singleton ${name}, but none exist! Did you forget to initialize?\nCall ${name}.create() before attempting to access, or consider using ${name}.use() instead.`,
+    AlreadyExists: (name) => `Shared instance of ${name} already exists! Consider unmounting existing, or use ${name}.reset() to force-delete it.`
 });
 const Active = new WeakMap();
 class Global extends MVC {
     static create(...args) {
         const Type = this;
         if (Active.has(Type))
-            throw Oops.GlobalExists(this.name);
+            throw Oops.AlreadyExists(this.name);
         const instance = super.create(...args);
         Active.set(Type, instance);
         return instance;
@@ -1366,7 +1371,7 @@ class Global extends MVC {
     static get(arg) {
         const instance = Active.get(this);
         if (!instance && arg !== false)
-            throw Oops.GlobalDoesNotExist(this.name);
+            throw Oops.DoesNotExist(this.name);
         return (typeof arg == "string" ?
             instance[arg] :
             instance);
@@ -1383,5 +1388,5 @@ class Global extends MVC {
     }
 }
 
-export { CONTROL, Consumer, Global, LOCAL, MVC as Model, Provider, STATE, WHY, act, apply, array, MVC as default, from, parent, ref, set, tap, use$1 as use, useFrom, useInContext, useModel, useTap };
+export { CONTROL, Consumer, Global, LOCAL, MVC as Model, Provider, STATE, WHY, act, apply, array, MVC as default, from, parent, ref, set, tap, use$1 as use, useFrom, useLocal, useModel, useTap };
 //# sourceMappingURL=index.esm.js.map