@expressive/mvc 1.0.0-beta.37 → 1.0.0-beta.38

package/lib/index.d.ts

@@ -35,7 +35,7 @@ declare class Subscriber<T extends Stateful = any> {
     active: boolean;
     dependant: Set<Listener>;
     watch: { [key in Model.Event<T, Model>]: true | Callback; };
-    constructor(parent: Controller<T> | T, onUpdate: Controller.OnEvent);
+    constructor(target: Controller<T> | T, onUpdate: Controller.OnEvent);
 }
 
 declare const CONTROL: unique symbol;
@@ -205,13 +205,14 @@ type Instruction<T> = (this: Controller, key: string, thisArg: Controller) =>
   | Instruction.ExplicitDescriptor
   | Instruction.Descriptor<T>
   | Instruction.RecursiveDescriptor<T>
+  | boolean
   | void;
 
 declare namespace Instruction {
   type Getter<T> = (state: T, within?: Subscriber) => T;
   type Setter<T> = (value: T, state: any) => boolean | void;
 
-  type Runner<T> = (this: Controller, key: string, on: Controller) => Instruction.Descriptor<T> | undefined;
+  type Runner<T> = (this: Controller, key: string, on: Controller) => Instruction.Descriptor<T> | boolean | undefined;
 
   interface Descriptor<T> {
     configurable?: boolean;
@@ -444,8 +445,8 @@ declare class MVC extends Model {
     static new<T extends Class>(this: T, callback?: (instance: InstanceOf<T>) => void): InstanceOf<T>;
     static use<T extends Class, I extends InstanceOf<T>>(this: T, watch: Model.Field<I>[], callback?: (instance: I) => void): I;
     static use<T extends Class, I extends InstanceOf<T>>(this: T, callback?: (instance: I) => void): I;
-    static uses<T extends typeof MVC, I extends InstanceOf<T>, D extends Partial<I>>(this: T, data: D, only?: (keyof D)[]): InstanceOf<T>;
-    static using<T extends typeof MVC, I extends InstanceOf<T>, D extends Partial<I>>(this: T, data: D, only?: (keyof D)[]): InstanceOf<T>;
+    static uses<T extends typeof MVC, I extends InstanceOf<T>, D extends Partial<I>>(this: T, data: D, only?: (keyof D & string)[]): InstanceOf<T>;
+    static using<T extends typeof MVC, I extends InstanceOf<T>, D extends Partial<I>>(this: T, data: D, only?: (keyof D & string)[]): InstanceOf<T>;
     static meta<T extends Class>(this: T): T;
     static meta<T extends Class, K extends keyof T>(this: T, key: K, expect: true): Exclude<T[K], undefined>;
     static meta<T extends Class, K extends keyof T>(this: T, key: K, expect?: boolean): T[K];
@@ -561,10 +562,12 @@ declare function useFrom<T extends Stateful, R>(source: (() => T) | T, compute:
 
 declare function useInContext<T extends typeof Model>(Type: T, arg?: boolean | string): any;
 
-declare function useModel<T extends Stateful>(source: (() => T) | T, watch?: Model.Field<T>[], callback?: (instance: T) => void): T;
-declare function useModel<T extends Stateful>(source: (() => T) | T, callback?: (instance: T) => void): T;
 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;
+declare function useModel<T extends Class, I extends InstanceOf<T>>(source: T, apply: Model.Compat<I>, keys?: Model.Event<I>[]): I;
+declare function useModel<T extends Stateful>(source: (() => T) | T, watch?: Model.Field<T>[], callback?: (instance: T) => void): T;
+declare function useModel<T extends Stateful>(source: (() => T) | T, callback?: (instance: T) => void): T;
+declare function useModel<T extends Stateful>(source: (() => T) | T, apply: Model.Compat<T>, keys?: Model.Event<T>[]): T;
 
 declare namespace useTap {
     interface Tappable {

package/lib/index.esm.js

@@ -113,13 +113,15 @@ class Controller {
             Pending.delete(entry);
             delete subject[key];
             const desc = instruction.call(this, key, this);
-            if (!desc)
+            if (desc === false)
                 return;
-            if ("value" in desc)
-                state[key] = desc.value;
-            onSet = desc.set;
-            onGet = desc.get;
-            enumerable = desc.enumerable;
+            if (typeof desc == "object") {
+                if ("value" in desc)
+                    state[key] = desc.value;
+                onSet = desc.set;
+                onGet = desc.get;
+                enumerable = desc.enumerable;
+            }
         }
         else
             state[key] = entry;
@@ -244,16 +246,15 @@ function control(subject, cb) {
 }
 
 class Subscriber {
-    constructor(parent, onUpdate) {
+    constructor(target, onUpdate) {
         this.onUpdate = onUpdate;
         this.active = false;
         this.dependant = new Set();
         this.watch = {};
-        if (!(parent instanceof Controller))
-            parent = control(parent);
-        let reset;
+        const parent = target instanceof Controller
+            ? target : control(target);
         const proxy = create(parent.proxy);
-        const controller = parent;
+        let reset;
         define(proxy, LOCAL, this);
         defineProperty(this, "proxy", {
             configurable: true,
@@ -263,29 +264,29 @@ class Subscriber {
                 return proxy;
             }
         });
-        const onEvent = (key) => {
+        const release = parent.addListener(key => {
             const handler = this.watch[key];
-            if (!handler)
+            if (!handler || !this.active)
                 return;
             if (typeof handler == "function")
                 handler();
-            const notify = this.onUpdate(key, controller);
+            const notify = this.onUpdate(key, parent);
             const getWhy = (keys) => {
                 reset = applyUpdate(proxy, keys.filter(k => k in this.watch));
             };
             if (notify) {
-                controller.requestUpdate(getWhy);
-                controller.requestUpdate(notify);
+                parent.requestUpdate(getWhy);
+                parent.requestUpdate(notify);
             }
-        };
+        });
         this.commit = () => {
-            const release = controller.addListener(onEvent);
             this.active = true;
             this.dependant.forEach(x => x.commit());
-            return this.release = () => {
-                this.dependant.forEach(x => x.release());
-                release();
-            };
+            return this.release;
+        };
+        this.release = () => {
+            this.dependant.forEach(x => x.release());
+            release();
         };
     }
 }
@@ -376,9 +377,8 @@ function prepare(parent, key, source, setter, getter) {
         configurable: true,
         enumerable: true
     });
-    return getter
-        ? () => getter(parent, key)
-        : {};
+    if (getter)
+        return () => getter(parent, key);
 }
 function ensure(on, keys) {
     for (const key of keys) {
@@ -552,18 +552,17 @@ function apply(fn, label) {
     const placeholder = Symbol(`${name} instruction`);
     function setup(key) {
         let output = fn.call(this, key, this);
-        if (!output)
-            return;
-        if ("explicit" in output) {
+        if (typeof output == "function")
+            return { get: output };
+        if (typeof output !== "object")
+            return output || undefined;
+        if ("explicit" in output && output.explicit) {
             defineProperty(this.subject, key, output);
-            return;
+            return false;
         }
         if ("recursive" in output)
             output = Object.assign(Object.assign({}, output), { get: recursive(this, key) });
-        if (typeof output == "function")
-            return { get: output };
-        else
-            return output;
+        return output;
     }
     Pending.set(placeholder, setup);
     return placeholder;
@@ -983,9 +982,9 @@ function use(init) {
     return state[0];
 }
 
-function useModel(source, arg, callback) {
+function useModel(source, arg, arg2) {
     const instance = React.useMemo(() => {
-        const cb = callback || arg;
+        const cb = arg2 || arg;
         const instance = typeof source == "function" ?
             source.prototype instanceof Model ?
                 new source() :
@@ -1009,9 +1008,18 @@ function useModel(source, arg, callback) {
         return instance;
     }
     else {
-        const local = use(refresh => {
-            return new Subscriber(instance, () => refresh);
-        });
+        const local = use(refresh => (new Subscriber(instance, () => refresh)));
+        if (typeof arg == "object") {
+            local.active = false;
+            if (typeof arg2 !== "object")
+                arg2 = getOwnPropertyNames(instance);
+            for (const key of arg2)
+                if (key in arg)
+                    instance[key] = arg[key];
+            React.useLayoutEffect(() => {
+                local.active = true;
+            });
+        }
         React.useLayoutEffect(() => {
             local.commit();
             return () => {
@@ -1094,10 +1102,11 @@ function useTap(source, path, expect) {
         }
         return sub;
     });
-    React.useLayoutEffect(() => local.commit(), []);
+    React.useLayoutEffect(local.commit, []);
     return local.proxy;
 }
 
+/* istanbul ignore file */
 class MVC extends Model {
     tap(path, expect) {
         return useTap(this, path, expect);
@@ -1202,7 +1211,7 @@ function RenderFunction(props) {
         return {};
     });
     if (hook.commit)
-        React.useLayoutEffect(() => hook.commit(), []);
+        React.useLayoutEffect(hook.commit, []);
     return props.render(hook.proxy);
 }