@expressive/mvc 1.0.0-beta.15 → 1.0.0-beta.17

package/lib/index.js

@@ -47,7 +47,8 @@ function setAlias(func, displayName) {
 function createEffect(callback) {
     let unSet;
     return function (value) {
-        typeof unSet == "function" && unSet();
+        if (typeof unSet == "function")
+            unSet();
         unSet = callback.call(this, value);
         if (unSet instanceof Promise)
             unSet = undefined;
@@ -55,6 +56,22 @@ function createEffect(callback) {
             throw Oops$8.BadEffectCallback();
     };
 }
+function createValueEffect(callback) {
+    let unSet;
+    return function (value) {
+        if (typeof unSet == "function")
+            unSet(value);
+        const out = callback.call(this, value);
+        if (typeof out == "boolean")
+            return out;
+        if (!out || out instanceof Promise)
+            return;
+        if (typeof out == "function")
+            unSet = out;
+        else
+            throw Oops$8.BadEffectCallback();
+    };
+}
 function select(source, select) {
     const proxy = {};
     for (const k in source)
@@ -447,10 +464,11 @@ function flush(on) {
 }
 
 const Oops$6 = issues({
-    DuplicateAction: (key) => `Invoked action ${key} but one is already active.`
+    DuplicateAction: (key) => `Invoked action ${key} but one is already active.`,
+    SourceNotSupported: () => `Computed from-instruction does not support source other than 'this'.`
 });
-const set = (instruction, name) => does(function set(key) {
-    let output = instruction.call(this, key, this);
+const set = (fn, name) => does(function set(key) {
+    let output = fn.call(this, key, this);
     if (typeof output == "function") {
         const getter = output;
         output = Object.assign(Object.assign({}, getOwnPropertyDescriptor(this.subject, key)), { get() {
@@ -459,9 +477,9 @@ const set = (instruction, name) => does(function set(key) {
     }
     if (output)
         defineProperty(this.subject, key, output);
-}, name || instruction.name || "pending");
+}, name || fn.name || "pending");
 const ref = (cb) => set(function ref(key) {
-    const refObjectFunction = this.setter(key, cb && createEffect(cb));
+    const refObjectFunction = this.setter(key, cb && createValueEffect(cb));
     defineProperty(refObjectFunction, "current", {
         set: refObjectFunction,
         get: () => this.state[key]
@@ -470,8 +488,8 @@ const ref = (cb) => set(function ref(key) {
         value: refObjectFunction
     };
 });
-const on = (value, cb) => set(function on(key) {
-    this.manage(key, value, cb && createEffect(cb));
+const on = (initial, cb) => set(function on(key) {
+    this.manage(key, initial, cb && createValueEffect(cb));
 });
 const memo = (factory, defer) => set(function memo(key) {
     const source = this.subject;
@@ -511,9 +529,19 @@ const act = (task) => set(function act(key) {
         writable: false
     };
 });
-const from = (getter) => set(function from(key) {
-    prepare(this, key, getter);
-});
+function from(source, fn) {
+    return set(function from(key) {
+        let getter;
+        if (typeof source == "function")
+            getter = source.call(this.subject, key);
+        else {
+            if (source !== this.subject)
+                throw Oops$6.SourceNotSupported();
+            getter = fn;
+        }
+        prepare(this, key, getter);
+    });
+}
 
 const attach = (from, name) => set(function attach(key) {
     const proxyCache = new WeakMap();
@@ -1058,6 +1086,9 @@ class Singleton extends Model {
         instance.import(updates);
         return instance.update();
     }
+    static is() {
+        return this.find(true);
+    }
     static find(strict) {
         const instance = this.current;
         if (!instance && strict)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@expressive/mvc",
-  "version": "1.0.0-beta.15",
+  "version": "1.0.0-beta.17",
   "description": "Use classes to define state in React!",
   "author": {
     "name": "Gabe Klein",

package/types/instructions.d.ts

@@ -1,5 +1,5 @@
-import Model from '.';
-import { Async, Class, EffectCallback, InstanceOf } from './types';
+import Model, { Selector } from '.';
+import { Async, Class, InstanceOf, InterceptCallback } from './types';
 
 /**
  * Run instruction as controller sets itself up.
@@ -99,15 +99,22 @@ export function tap <T extends typeof Model> (Type: T, callback?: (instance?: In
  * @param required - Throw if instance of Type cannot be found.
  */
 export function tap <T extends Class> (Type: T, required?: boolean): InstanceOf<T>;
- 
+
 /**
- * Sets property to synchronously call effect upon update.
+ * Cause property to synchronously run effect upon update.
+ * 
+ * Callback may return an effect callback, Promise (ignored), or a boolean.
+ * 
+ * If a boolean is returned explicitly, new value will be dropped. Useful to override.
+ * 
+ * - `false` will prevent update.
+ * - `true` will emit update (unchanged).
  *
- * @param starting - Beginning value of host property.
- * @param callback - Effect-callback fired upon set of host property.
+ * @param initialValue - Beginning value of host property.
+ * @param onUpdate - Effect-callback fired upon set of host property.
  */
-export function on <T = any> (initial: undefined, callback: EffectCallback<T>): T | undefined;
-export function on <T = any> (initial: T, callback: EffectCallback<T>): T;
+export function on <T = any> (initialValue: undefined, onUpdate: InterceptCallback<T>): T | undefined;
+export function on <T = any> (initialValue: T, onUpdate: InterceptCallback<T>): T;
 
 /**
  * Creates a ref-compatible property for use with components.
@@ -117,7 +124,7 @@ export function on <T = any> (initial: T, callback: EffectCallback<T>): T;
  *
  * @param callback - Optional callback to synchronously fire when reference is first set or does update.
  */
-export function ref <T = HTMLElement> (this: any, callback?: (value: T) => Callback | Promise<any> | void): Model.Ref<T>;
+export function ref <T = HTMLElement> (this: any, callback?: InterceptCallback<T>): Model.Ref<T>;
 
 /**
  * Sets an exotic method with managed ready-state. Property accepts an async function.
@@ -130,15 +137,24 @@ export function ref <T = HTMLElement> (this: any, callback?: (value: T) => Callb
  * @param action - Action to fire when resulting property is invoked.
  */
 export function act <T extends Async> (action: T): T & { active: boolean };
- 
+
 /**
- * Implement a computed value; output will be generated by provided function.
+ * Implement a computed value; output is returned by function from provided factory.
  *
- * *Alternative to using native getters; works exactly the same!*
+ * @param fn - Factory function to generate a getter to subscribe dependancies.
+ */
+export function from <R> (fn: (property: string) => (this: any, on: any) => R): R;
+
+/**
+ * Implement a computed value; output will be generated by provided function.
  *
- * @param fn - Factory function to generate value and subscribe dependancies.
+ * @param source - Source model from which computed value will be subscribed.
+ * **Note:** Currently will only support `this`.
+ * 
+ * @param fn - Compute function. Bound to a subscriber-proxy of source, returns output value.
+ * Will update automatically as accessed values change.
  */
-export function from <T, R> (fn: (this: T, on: T) => R): R;
+export function from <T, R> (source: T, fn: (this: T, on: T) => R): R;
 
 /**
  * Memoized value. Computes and stores a value returned by provided factory. 

package/types/model.d.ts

@@ -476,6 +476,9 @@ export abstract class Model extends State {
 }
 
 export class Singleton extends Model {
+    /** Get current instance of this singleton. Will throw if one does not exist. */
+    static is<T extends Class>(this: T): InstanceOf<T>;
+
     /**
      * Update the active instance of this class.
      * Returns a thenable; resolves after successful update.

package/types/types.d.ts

@@ -10,5 +10,6 @@ export type Callback = () => void;
 export type RequestCallback = (keys?: string[]) => void;
 export type EffectCallback<T, A = T> = (this: T, argument: A) => Callback | Promise<any> | void;
 export type UpdateCallback<T, P> = (this: T, value: IfApplicable<T, P>, changed: P) => void;
+export type InterceptCallback<T> = (argument: T) => ((next: T) => void) | Promise<any> | void | boolean;
 
 export type RefFunction = (e: HTMLElement | null) => void;