@expressive/mvc 0.2.0 → 0.2.3

package/lib/index.d.ts

@@ -364,6 +364,18 @@ declare function set<T>(factory: set.Factory<T>, required?: boolean): T;
 declare function set<T, S>(factory: set.Factory<T, S>, required?: boolean): T;
 declare function set<T>(value: set.Factory<T>, onUpdate: set.Callback<T>): T;
 declare function set<T, S>(value: set.Factory<T, S>, onUpdate: set.Callback<T, S>): T;
+/**
+ * Assign a property with result of a promise.
+ */
+declare function set<T>(factory: Promise<T>, required: false): T | undefined;
+declare function set<T>(factory: Promise<T>, required?: boolean): T;
+declare function set<T>(value: Promise<T>, onUpdate: set.Callback<T>): T;
+/**
+ * Assign a property.
+ */
+declare function set<T>(factory: T, required: false): T | undefined;
+declare function set<T>(factory: T, required?: boolean): T;
+declare function set<T>(value: T, onUpdate: set.Callback<T>): T;
 
 /**
  * Create a placeholder for specified Model type.
@@ -418,19 +430,26 @@ declare class MVC extends Model {
     /**
      * **React Hook** - Fetch most instance of this controller from context, if it exists.
      *
-     * @param required - If false, may return undefined.
+     * @param required - Unless false, will throw where instance cannot be found.
      */
-    static get<T extends Class>(this: T, required?: true): InstanceOf<T>;
+    static get<T extends Class>(this: T, required?: boolean): InstanceOf<T>;
     /**
      * **React Hook** - Fetch most instance of this controller from context.
      *
-     * @param required - Unless false, will throw where instance cannot be found.
+     * @param required - If false, may return undefined.
      */
-    static get<T extends Class>(this: T, required: boolean): InstanceOf<T> | undefined;
+    static get<T extends Class>(this: T, required: false): InstanceOf<T> | undefined;
     /**
      * **React Hook** - Fetch specific value from instance of this controller in context.
      */
     static get<T extends Class, I extends InstanceOf<T>, K extends Model.Field<I>>(this: T, key: K): I[K];
+    /**
+     * **React Hook** - Fetch instance.
+     *
+     * Effect callback will run once if found, throw if not found.
+     * Returned function is called on unmount.
+     */
+    static get<T extends Class, I extends InstanceOf<T>>(type: T, effect: (found: I) => Callback | void): I;
     /**
      * **React Hook** - Fetch and subscribe to instance of this controller within ambient component.
      */
@@ -599,7 +618,10 @@ 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 useLocal<T extends typeof Model>(Type: T, arg?: boolean | string): any;
+declare function useLocal<T extends typeof Model>(Type: T, required: false): InstanceOf<T> | undefined;
+declare function useLocal<T extends typeof Model>(Type: T, arg?: boolean): InstanceOf<T>;
+declare function useLocal<T extends typeof Model, I extends InstanceOf<T>>(Type: T, effect: (found: I) => Callback | void): I;
+declare function useLocal<T extends typeof Model, I extends InstanceOf<T>, K extends Model.Field<I>>(Type: T, key: K): I[K];
 
 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;

package/lib/index.esm.js

@@ -1,4 +1,4 @@
-import React, { useState, useMemo } from 'react';
+import React, { useLayoutEffect, useState, useMemo } from 'react';
 
 /*! *****************************************************************************
 Copyright (c) Microsoft Corporation.
@@ -824,28 +824,74 @@ 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.`,
     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) {
+        const { subject, state } = this;
+        const required = argument === true || argument === undefined;
         let set;
         let get;
         let suspense;
-        const required = argument === true || argument === undefined;
         if (factory === undefined)
             suspense = true;
-        else if (typeof factory === "function")
-            get = pendingFactory(this, key, factory, required);
-        else
-            throw Oops$7.BadFactory();
+        else {
+            let pending;
+            let error;
+            const init = () => {
+                const output = typeof factory == "function" ?
+                    mayRetry(() => factory.call(subject, key, subject)) :
+                    factory;
+                if (output instanceof Promise) {
+                    pending = output
+                        .catch(err => error = err)
+                        .then(val => state[key] = val)
+                        .finally(() => {
+                        pending = undefined;
+                        this.update(key);
+                    });
+                    return;
+                }
+                return state[key] = output;
+            };
+            const suspend = () => {
+                if (required === false)
+                    return undefined;
+                const issue = Oops$7.NotReady(subject, key);
+                Object.assign(pending, {
+                    message: issue.message,
+                    stack: issue.stack
+                });
+                throw pending;
+            };
+            if (required)
+                try {
+                    init();
+                }
+                catch (err) {
+                    Oops$7.Failed(subject, key).warn();
+                    throw err;
+                }
+            get = () => {
+                if (pending)
+                    return suspend();
+                if (error)
+                    throw error;
+                if (key in state)
+                    return state[key];
+                let output = init();
+                return pending
+                    ? suspend()
+                    : output;
+            };
+        }
         if (typeof argument == "function")
             set = createValueEffect(argument);
         else
             set = (value) => {
                 if (value === undefined && required)
-                    throw Oops$7.NonOptional(this.subject, key);
+                    throw Oops$7.NonOptional(subject, key);
             };
         return {
             set,
@@ -853,57 +899,6 @@ function set(factory, argument) {
             suspense
         };
     });
-}
-function pendingFactory(parent, key, fn, required) {
-    const { subject, state } = parent;
-    let pending;
-    let error;
-    const init = () => {
-        const output = mayRetry(() => {
-            return fn.call(subject, key, subject);
-        });
-        if (output instanceof Promise) {
-            pending = output
-                .catch(err => error = err)
-                .then(val => state[key] = val)
-                .finally(() => {
-                pending = undefined;
-                parent.update(key);
-            });
-            return;
-        }
-        return state[key] = output;
-    };
-    const suspend = () => {
-        if (required === false)
-            return undefined;
-        const issue = Oops$7.NotReady(subject, key);
-        Object.assign(pending, {
-            message: issue.message,
-            stack: issue.stack
-        });
-        throw pending;
-    };
-    if (required)
-        try {
-            init();
-        }
-        catch (err) {
-            Oops$7.Failed(subject, key).warn();
-            throw err;
-        }
-    return () => {
-        if (pending)
-            return suspend();
-        if (error)
-            throw error;
-        if (key in state)
-            return state[key];
-        let output = init();
-        return pending
-            ? suspend()
-            : output;
-    };
 }
 
 const Parent = new WeakMap();
@@ -1032,9 +1027,14 @@ function useLocal(Type, arg) {
     const instance = useLookup().get(Type);
     if (!instance && arg !== false)
         throw Oops$4.NotFound(Type.name);
-    return typeof arg == "string" ?
-        instance[arg] :
-        instance;
+    switch (typeof arg) {
+        case "string":
+            return instance[arg];
+        case "function":
+            useLayoutEffect(() => arg(instance), []);
+        default:
+            return instance;
+    }
 }
 
 const Oops$3 = issues({
@@ -1230,8 +1230,8 @@ class MVC extends Model {
     use(arg, callback) {
         return useModel(this, arg, callback);
     }
-    static get(required) {
-        return useLocal(this, required);
+    static get(arg) {
+        return useLocal(this, arg);
     }
     static tap(key, expect) {
         return useTap(this, key, expect);