@expressive/mvc 0.2.6 → 0.3.0

package/lib/index.d.ts

@@ -300,30 +300,10 @@ declare function ref<T extends Model>(target: T): ref.Proxy<T>;
 declare function ref<T = HTMLElement>(callback?: ref.Callback<T>): ref.Object<T>;
 declare function ref<T, S>(callback?: ref.Callback<T, S>): ref.Object<T>;
 
-declare namespace set {
+declare namespace set$1 {
     type Factory<T, S = unknown> = (this: S, key: string, subject: S) => T;
     type Callback<T, S = any> = (this: S, argument: T) => ((next: T) => void) | Promise<any> | void | boolean;
 }
-/**
- * Set property with a placeholder.
- *
- * Property cannot be accessed until it is defined. If accessed while undefined, a hybrid
- * `Promise`/`Error` (ala: [Suspense](https://reactjs.org/docs/concurrent-mode-suspense.html)) will be thrown.
- */
-declare function set<T = any>(): T;
-/**
- * Set property with starting value `undefined`.
- *
- * If required and accessed while still empty, React Suspense will be thrown.
- * Property will reject any assignment of undefined.
- *
- * @param value - Starting value of host property (undefined).
- * @param required - Property will suspend callee if undefined at time of access.
- */
-declare function set<T>(value: undefined, required: false): T | undefined;
-declare function set<T>(value: undefined, required?: boolean): T;
-declare function set<T>(value: undefined, onUpdate: set.Callback<T>): T | undefined;
-declare function set<T, S>(value: undefined, onUpdate: set.Callback<T, S>): T | undefined;
 /**
  * Set property with an async function.
  *
@@ -339,12 +319,12 @@ declare function set<T, S>(value: undefined, onUpdate: set.Callback<T, S>): T |
  * @param factory - Callback run to derrive property value.
  * @param required - (default: true) Run factory immediately on creation, otherwise on access.
  */
-declare function set<T>(factory: set.Factory<Promise<T>>, required: false): T | undefined;
-declare function set<T, S>(factory: set.Factory<Promise<T>, S>, required: false): T | undefined;
-declare function set<T>(factory: set.Factory<Promise<T>>, required?: boolean): T;
-declare function set<T, S>(factory: set.Factory<Promise<T>, S>, required?: boolean): T;
-declare function set<T>(value: set.Factory<Promise<T>>, onUpdate: set.Callback<T>): T;
-declare function set<T, S>(value: set.Factory<Promise<T>, S>, onUpdate: set.Callback<T, S>): T;
+declare function put<T>(factory: set$1.Factory<Promise<T>>, required: false): T | undefined;
+declare function put<T, S>(factory: set$1.Factory<Promise<T>, S>, required: false): T | undefined;
+declare function put<T>(factory: set$1.Factory<Promise<T>>, required?: boolean): T;
+declare function put<T, S>(factory: set$1.Factory<Promise<T>, S>, required?: boolean): T;
+declare function put<T>(value: set$1.Factory<Promise<T>>, onUpdate: set$1.Callback<T>): T;
+declare function put<T, S>(value: set$1.Factory<Promise<T>, S>, onUpdate: set$1.Callback<T, S>): T;
 /**
  * Set property with a factory function.
  *
@@ -357,24 +337,41 @@ declare function set<T, S>(value: set.Factory<Promise<T>, S>, onUpdate: set.Call
  * @param factory - Callback run to derrive property value.
  * @param required - (default: true) Run factory immediately on creation, otherwise on access.
  */
-declare function set<T>(factory: set.Factory<T>, required: false): T | undefined;
-declare function set<T, S>(factory: set.Factory<T, S>, required: false): T | undefined;
-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;
+declare function put<T>(factory: set$1.Factory<T>, required: false): T | undefined;
+declare function put<T, S>(factory: set$1.Factory<T, S>, required: false): T | undefined;
+declare function put<T>(factory: set$1.Factory<T>, required?: boolean): T;
+declare function put<T, S>(factory: set$1.Factory<T, S>, required?: boolean): T;
+declare function put<T>(value: set$1.Factory<T>, onUpdate: set$1.Callback<T>): T;
+declare function put<T, S>(value: set$1.Factory<T, S>, onUpdate: set$1.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;
+declare function put<T>(factory: Promise<T>, required: false): T | undefined;
+declare function put<T>(factory: Promise<T>, required?: boolean): T;
+declare function put<T>(value: Promise<T>, onUpdate: set$1.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 put<T>(factory: T, required: false): T | undefined;
+declare function put<T>(factory: T, required?: boolean): T;
+declare function put<T>(value: T, onUpdate: set$1.Callback<T>): T;
+
+declare namespace set {
+    type Callback<T, S = any> = (this: S, argument: T) => ((next: T) => void) | Promise<any> | void | boolean;
+}
+/**
+ * Set property with a placeholder.
+ *
+ * Property cannot be accessed until it is defined. If accessed while undefined, a hybrid
+ * `Promise`/`Error` (ala: [Suspense](https://reactjs.org/docs/concurrent-mode-suspense.html)) will be thrown.
+ */
+declare function set<T = any>(): T;
+declare function set<T>(onUpdate: set.Callback<T>): T;
+declare function set<T, S>(onUpdate: set.Callback<T, S>): T;
+declare function set<T>(value: undefined, onUpdate: set.Callback<T>): T;
+declare function set<T, S>(value: undefined, onUpdate: set.Callback<T, S>): T;
 declare function set<T>(value: T, onUpdate: set.Callback<T>): T;
+declare function set<T, S>(value: T, onUpdate: set.Callback<T, S>): T;
 
 /**
  * Create a placeholder for specified Model type.
@@ -642,4 +639,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, useLocal, useModel, useTap };
+export { CONTROL, Consumer, Global, LOCAL, MVC as Model, Provider, STATE, Stateful, WHY, act, apply, array, MVC as default, from, parent, put, ref, set, tap, use, useFrom, useLocal, useModel, useTap };

package/lib/index.esm.js

@@ -843,65 +843,60 @@ const Oops$7 = issues({
     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) {
+function put(factory, argument) {
     return apply(function set(key) {
         const { subject, state } = this;
         const required = argument === true || argument === undefined;
         let set;
         let get;
-        let suspense;
-        if (factory === undefined)
-            suspense = true;
-        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
+        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);
                 });
-                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;
-            };
-        }
+                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
@@ -911,8 +906,24 @@ function set(factory, argument) {
             };
         return {
             set,
-            get,
-            suspense
+            get
+        };
+    });
+}
+
+function set(value, argument) {
+    if (!(1 in arguments)) {
+        argument = value;
+        value = undefined;
+    }
+    return apply(function set(key) {
+        if (value !== undefined)
+            this.state[key] = value;
+        return {
+            suspense: true,
+            set: typeof argument == "function"
+                ? createValueEffect(argument)
+                : undefined
         };
     });
 }
@@ -1404,5 +1415,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, useLocal, useModel, useTap };
+export { CONTROL, Consumer, Global, LOCAL, MVC as Model, Provider, STATE, WHY, act, apply, array, MVC as default, from, parent, put, ref, set, tap, use$1 as use, useFrom, useLocal, useModel, useTap };
 //# sourceMappingURL=index.esm.js.map