@expressive/mvc 0.6.3 → 0.7.2

package/lib/index.d.ts

@@ -53,11 +53,6 @@ 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.
      *
@@ -92,13 +87,6 @@ interface Model extends Stateful {
      * Useful to obtain full reference where one has already destructured.
      */
     is: this;
-    /**
-    * Setter utility
-    *
-    * Can be used to set (and force-update) values.
-    * Shortcut to update values, contains refs for all controlled values.
-    */
-    set: Model.Refs<this>;
 }
 declare class Model {
     static [WHY]: readonly string[];
@@ -145,7 +133,7 @@ declare class Model {
      *
      * @param args - arguments sent to constructor
      */
-    static create<T extends Class>(this: T, ...args: any[]): InstanceOf<T>;
+    static create<T extends Class>(this: T, ...args: ConstructorParameters<T>): InstanceOf<T>;
     /**
      * Static equivalent of `x instanceof this`.
      *
@@ -298,9 +286,30 @@ declare namespace ref {
     }
     /** Object with references to all managed values of `T`. */
     type Proxy<T extends Model> = {
-        [P in Model.Field<T>]: Model.Ref<T[P]>;
+        [P in Model.Field<T>]-?: Model.Ref<T[P]>;
+    };
+    type CustomProxy<T extends Model, R> = {
+        [P in Model.Field<T>]-?: R;
     };
 }
+/**
+ * Creates an object with references to all managed values.
+ * Each property is a function to 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.
+ */
+declare function ref<T extends Model>(target: T): ref.Proxy<T>;
+/**
+ * Creates an object with values based on managed values.
+ * Each property will invoke mapper function on first access supply
+ * the its return value going forward.
+ *
+ * @param target - Source model from which to reference values.
+ * @param mapper - Function producing the placeholder value for any given property.
+ */
+declare function ref<O extends Model, R>(target: O, mapper: (key: Model.Field<O>) => R): ref.CustomProxy<O, R>;
 /**
  * Creates a ref-compatible property.
  * Will persist value, and updates to this are made part of controller event-stream.
@@ -497,16 +506,13 @@ declare namespace Consumer {
 }
 declare function Consumer<T extends Class>(props: Consumer.Props<T>): any;
 
-declare type Collection = Array<Model | typeof Model> | {
-    [anything: string]: Model | typeof Model;
-};
 declare class Lookup {
     private table;
     get local(): Model[];
     private key;
     get(T: typeof Model): any;
-    push(I: Model | typeof Model | Collection): this;
-    register(I: Model | typeof Model): Model;
+    push(): this;
+    inject(T: typeof Model, I: Model, writable?: boolean): void;
     pop(): void;
 }
 
@@ -533,13 +539,13 @@ declare namespace Provider {
 declare function Provider<T extends Provider.Item>(props: Provider.Props<T>): React.FunctionComponentElement<React.ProviderProps<Lookup>>;
 
 declare class Global extends MVC {
-    static create<T extends Class>(this: T, ...args: any[]): InstanceOf<T>;
+    static create<T extends Class>(this: T, ...args: ConstructorParameters<T>): InstanceOf<T>;
     /**
      * Update the active instance of this class.
      * Returns a thenable; resolves after successful update.
      * If instance does not already exist, one will be created.
      */
-    static set<T extends typeof Global>(this: T, updates: Partial<InstanceOf<T>>): Promise<false>;
+    static set<T extends typeof Global>(this: T, updates: Partial<InstanceOf<T>>): any;
     /**
      * **React Hook** - Fetch most instance of this controller from context, if it exists.
      *

package/lib/index.esm.js

@@ -196,22 +196,6 @@ class Model {
         defineProperty(this, "is", {
             value: this
         });
-        defineProperty(this, "set", {
-            configurable: true,
-            get: () => {
-                const controller = ensure(this);
-                const value = (key, value) => {
-                    controller.state.set(key, value);
-                    controller.update(key);
-                };
-                for (const key of controller.state.keys())
-                    defineProperty(value, key, {
-                        value: controller.ref(key)
-                    });
-                defineProperty(this, "set", { value });
-                return value;
-            }
-        });
     }
     get [STATE]() {
         return this.export();
@@ -474,8 +458,11 @@ class Controller {
             return;
         if (typeof value == "symbol") {
             const instruction = PENDING.get(value);
-            if (instruction)
+            if (instruction) {
+                delete subject[key];
+                PENDING.delete(value);
                 instruction.call(this, key, this);
+            }
             return;
         }
         state.set(key, value);
@@ -579,9 +566,6 @@ function apply(fn, label) {
     const placeholder = Symbol(`${name} instruction`);
     function setup(key) {
         const { subject, state } = this;
-        const control = this;
-        PENDING.delete(placeholder);
-        delete subject[key];
         let output = fn.call(this, key, this);
         if (typeof output == "function")
             output = { get: output };
@@ -604,6 +588,7 @@ function apply(fn, label) {
                         destroy();
                 });
         }
+        const control = this;
         defineProperty(subject, key, {
             enumerable: output.enumerable,
             set: onSet !== false
@@ -797,7 +782,7 @@ function get(arg0, arg1, arg2) {
                 throw new Error(`Factory argument cannot be ${arg1}`);
             getter = computeMode(this, source, setter, key, computeRequired);
         };
-        if (typeof arg0 == "function" && factoryRequired)
+        if (typeof arg0 == "function" && computeRequired)
             try {
                 init();
             }
@@ -813,18 +798,34 @@ function get(arg0, arg1, arg2) {
     });
 }
 
-function ref(callback) {
+function ref(arg, mapper) {
     return apply(function ref(key) {
-        const value = this.ref(key, callback && createValueEffect(callback));
-        defineProperty(value, "current", {
-            set: value,
-            get: () => this.state.get(key)
-        });
-        return {
-            value,
-            explicit: true
-        };
+        let value = {};
+        if (typeof arg != "object")
+            value = createRef(this, key, arg);
+        else
+            ensure(arg).state.forEach((_val, key) => {
+                defineProperty(value, key, mapper ? {
+                    configurable: true,
+                    get() {
+                        const out = mapper(key);
+                        defineProperty(value, key, { value: out });
+                        return out;
+                    }
+                } : {
+                    value: createRef(this, key)
+                });
+            });
+        return { value, explicit: true };
     });
+}
+function createRef(src, key, cb) {
+    const refObjectFunction = src.ref(key, cb && createValueEffect(cb));
+    defineProperty(refObjectFunction, "current", {
+        set: refObjectFunction,
+        get: () => src.state.get(key)
+    });
+    return refObjectFunction;
 }
 
 function set(value, argument) {
@@ -921,12 +922,15 @@ function createProxy(emit, watch) {
         assign(proxy, {
             from,
             delete(key) {
+                // TODO: this commit's fix needs tests.
+                // Was not cause by coverage.
+                const out = from.delete(key);
                 emit(key);
-                return from.delete(key);
+                return out;
             },
             clear() {
-                emit(ANY);
                 from.clear();
+                emit(ANY);
             },
             has(key) {
                 watch(this, key);
@@ -1106,26 +1110,10 @@ class Lookup {
     get(T) {
         return this[this.key(T)];
     }
-    push(I) {
-        const next = create(this);
-        if (I instanceof Model || typeof I == "function")
-            next.register(I);
-        else
-            for (const i of values(I))
-                next.register(i);
-        return next;
+    push() {
+        return create(this);
     }
-    register(I) {
-        let writable = true;
-        let T;
-        if (I instanceof Model) {
-            T = I.constructor;
-            writable = false;
-        }
-        else {
-            T = I;
-            I = I.create();
-        }
+    inject(T, I, writable) {
         do {
             const key = this.key(T);
             const conflict = this.hasOwnProperty(key);
@@ -1136,7 +1124,6 @@ class Lookup {
             });
             T = getPrototypeOf(T);
         } while (T !== Model);
-        return I;
     }
     pop() {
         for (const key of getOwnPropertySymbols(this)) {
@@ -1419,7 +1406,28 @@ const Oops$1 = issues({
 function Provider(props) {
     if ("of" in props)
         throw Oops$1.PropDeprecated();
-    const context = useNewContext(props.for);
+    const from = useLookup();
+    const context = React.useMemo(() => {
+        const I = props.for;
+        if (!I)
+            throw Oops$1.NoType();
+        const layer = from.push();
+        function register(I) {
+            if (I instanceof Model)
+                layer.inject(I.constructor, I, false);
+            else
+                layer.inject(I, I.create(), true);
+        }
+        if (I instanceof Model || typeof I == "function")
+            register(I);
+        else
+            values(I).forEach(register);
+        for (const instance of layer.local)
+            if (instance)
+                for (const apply of getPending(instance))
+                    apply(layer);
+        return layer;
+    }, []);
     const render = props.children;
     useAppliedProps(context, props);
     React.useLayoutEffect(() => () => context.pop(), []);
@@ -1427,19 +1435,6 @@ function Provider(props) {
         ? React.createElement(RenderFunction, { context, render })
         : render);
 }
-function useNewContext(inject) {
-    const from = useLookup();
-    return React.useMemo(() => {
-        if (!inject)
-            throw Oops$1.NoType();
-        const context = from.push(inject);
-        for (const instance of context.local)
-            if (instance)
-                for (const apply of getPending(instance))
-                    apply(context);
-        return context;
-    }, []);
-}
 function useAppliedProps(within, props) {
     const update = React.useMemo(() => {
         const targets = within.local;
@@ -1472,11 +1467,11 @@ const Oops = issues({
 const Active = new WeakMap();
 class Global extends MVC {
     static create(...args) {
-        const Type = this;
-        if (Active.has(Type))
+        if (Active.has(this))
             throw Oops.AlreadyExists(this.name);
-        const instance = super.create(...args);
-        Active.set(Type, instance);
+        const instance = new this(...args);
+        ensure(instance);
+        Active.set(this, instance);
         return instance;
     }
     /**