mobx 6.1.8 → 6.9.0

package/dist/types/actionannotation.d.ts

@@ -1,2 +1,8 @@
-import { Annotation } from "../internal";
+import { ObservableObjectAdministration, Annotation } from "../internal";
 export declare function createActionAnnotation(name: string, options?: object): Annotation;
+export declare function createActionDescriptor(adm: ObservableObjectAdministration, annotation: Annotation, key: PropertyKey, descriptor: PropertyDescriptor, safeDescriptors?: boolean): {
+    value: Function;
+    configurable: boolean;
+    enumerable: boolean;
+    writable: boolean;
+};

package/dist/types/autoannotation.d.ts

@@ -0,0 +1,3 @@
+import { Annotation } from "../internal";
+export declare const autoAnnotation: Annotation;
+export declare function createAutoAnnotation(options?: object): Annotation;

package/dist/types/observablemap.d.ts

@@ -3,7 +3,9 @@ export interface IKeyValueMap<V = any> {
     [key: string]: V;
 }
 export declare type IMapEntry<K = any, V = any> = [K, V];
+export declare type IReadonlyMapEntry<K = any, V = any> = readonly [K, V];
 export declare type IMapEntries<K = any, V = any> = IMapEntry<K, V>[];
+export declare type IReadonlyMapEntries<K = any, V = any> = IReadonlyMapEntry<K, V>[];
 export declare type IMapDidChange<K = any, V = any> = {
     observableKind: "map";
     debugObjectName: string;
@@ -32,7 +34,7 @@ export interface IMapWillChange<K = any, V = any> {
 }
 export declare const ADD = "add";
 export declare const DELETE = "delete";
-export declare type IObservableMapInitialValues<K = any, V = any> = IMapEntries<K, V> | IKeyValueMap<V> | Map<K, V>;
+export declare type IObservableMapInitialValues<K = any, V = any> = IMapEntries<K, V> | IReadonlyMapEntries<K, V> | IKeyValueMap<V> | Map<K, V>;
 export declare class ObservableMap<K = any, V = any> implements Map<K, V>, IInterceptable<IMapWillChange<K, V>>, IListenable {
     enhancer_: IEnhancer<V>;
     name_: string;
@@ -48,7 +50,6 @@ export declare class ObservableMap<K = any, V = any> implements Map<K, V>, IInte
     has(key: K): boolean;
     set(key: K, value: V): this;
     delete(key: K): boolean;
-    private updateHasMapEntry_;
     private updateValue_;
     private addValue_;
     get(key: K): V | undefined;
@@ -59,9 +60,9 @@ export declare class ObservableMap<K = any, V = any> implements Map<K, V>, IInte
     [Symbol.iterator](): IterableIterator<IMapEntry<K, V>>;
     forEach(callback: (value: V, key: K, object: Map<K, V>) => void, thisArg?: any): void;
     /** Merge another object into this object, returns this. */
-    merge(other: ObservableMap<K, V> | IKeyValueMap<V> | any): ObservableMap<K, V>;
+    merge(other?: IObservableMapInitialValues<K, V>): ObservableMap<K, V>;
     clear(): void;
-    replace(values: ObservableMap<K, V> | IKeyValueMap<V> | any): ObservableMap<K, V>;
+    replace(values: IObservableMapInitialValues<K, V>): ObservableMap<K, V>;
     get size(): number;
     toString(): string;
     toJSON(): [K, V][];

package/dist/types/observableobject.d.ts

@@ -1,5 +1,4 @@
 import { CreateObservableOptions, Annotation, ComputedValue, IAtom, IComputedValueOptions, IEnhancer, IInterceptable, IListenable, Lambda, ObservableValue } from "../internal";
-export declare const inferredAnnotationsSymbol: unique symbol;
 export declare type IObjectDidChange<T = any> = {
     observableKind: "object";
     name: PropertyKey;
@@ -28,10 +27,9 @@ export declare type IObjectWillChange<T = any> = {
 };
 export declare class ObservableObjectAdministration implements IInterceptable<IObjectWillChange>, IListenable {
     target_: any;
-    values_: Map<string | number | symbol, ObservableValue<any> | ComputedValue<any>>;
+    values_: Map<PropertyKey, ObservableValue<any> | ComputedValue<any>>;
     name_: string;
     defaultAnnotation_: Annotation;
-    autoBind_: boolean;
     keysAtom_: IAtom;
     changeListeners_: any;
     interceptors_: any;
@@ -39,14 +37,14 @@ export declare class ObservableObjectAdministration implements IInterceptable<IO
     isPlainObject_: boolean;
     appliedAnnotations_?: object;
     private pendingKeys_;
-    constructor(target_: any, values_: Map<string | number | symbol, ObservableValue<any> | ComputedValue<any>>, name_: string, defaultAnnotation_?: Annotation, autoBind_?: boolean);
+    constructor(target_: any, values_: Map<PropertyKey, ObservableValue<any> | ComputedValue<any>>, name_: string, defaultAnnotation_?: Annotation);
     getObservablePropValue_(key: PropertyKey): any;
     setObservablePropValue_(key: PropertyKey, newValue: any): boolean | null;
     get_(key: PropertyKey): any;
     /**
      * @param {PropertyKey} key
      * @param {any} value
-     * @param {Annotation|boolean} annotation true - infer from descriptor, false - copy as is
+     * @param {Annotation|boolean} annotation true - use default annotation, false - copy as is
      * @param {boolean} proxyTrap whether it's called from proxy trap
      * @returns {boolean|null} true on success, false on failure (proxyTrap + non-configurable), null when cancelled by interceptor
      */
@@ -54,18 +52,17 @@ export declare class ObservableObjectAdministration implements IInterceptable<IO
     has_(key: PropertyKey): boolean;
     /**
      * @param {PropertyKey} key
-     * @param {Annotation|boolean} annotation true - infer from object or it's prototype, false - ignore
+     * @param {Annotation|boolean} annotation true - use default annotation, false - ignore prop
      */
     make_(key: PropertyKey, annotation: Annotation | boolean): void;
     /**
      * @param {PropertyKey} key
      * @param {PropertyDescriptor} descriptor
-     * @param {Annotation|boolean} annotation true - infer from descriptor, false - copy as is
+     * @param {Annotation|boolean} annotation true - use default annotation, false - copy as is
      * @param {boolean} proxyTrap whether it's called from proxy trap
      * @returns {boolean|null} true on success, false on failure (proxyTrap + non-configurable), null when cancelled by interceptor
      */
     extend_(key: PropertyKey, descriptor: PropertyDescriptor, annotation: Annotation | boolean, proxyTrap?: boolean): boolean | null;
-    inferAnnotation_(key: PropertyKey): Annotation | false;
     /**
      * @param {PropertyKey} key
      * @param {PropertyDescriptor} descriptor
@@ -90,7 +87,7 @@ export declare class ObservableObjectAdministration implements IInterceptable<IO
     observe_(callback: (changes: IObjectDidChange) => void, fireImmediately?: boolean): Lambda;
     intercept_(handler: any): Lambda;
     notifyPropertyAddition_(key: PropertyKey, value: any): void;
-    ownKeys_(): PropertyKey[];
+    ownKeys_(): ArrayLike<string | symbol>;
     keys_(): PropertyKey[];
 }
 export interface IIsObservableObject {

package/dist/types/observableset.d.ts

@@ -1,4 +1,4 @@
-import { $mobx, IEnhancer, IListenable, Lambda, IInterceptable, IInterceptor } from "../internal";
+import { $mobx, IEnhancer, IListenable, Lambda, IInterceptable, IInterceptor, IAtom } from "../internal";
 export declare type IObservableSetInitialValues<T> = Set<T> | readonly T[];
 export declare type ISetDidChange<T = any> = {
     object: ObservableSet<T>;
@@ -26,7 +26,7 @@ export declare class ObservableSet<T = any> implements Set<T>, IInterceptable<IS
     name_: string;
     [$mobx]: {};
     private data_;
-    private atom_;
+    atom_: IAtom;
     changeListeners_: any;
     interceptors_: any;
     dehancer: any;
@@ -37,8 +37,8 @@ export declare class ObservableSet<T = any> implements Set<T>, IInterceptable<IS
     forEach(callbackFn: (value: T, value2: T, set: Set<T>) => void, thisArg?: any): void;
     get size(): number;
     add(value: T): this;
-    delete(value: any): boolean;
-    has(value: any): boolean;
+    delete(value: T): boolean;
+    has(value: T): boolean;
     entries(): IterableIterator<[T, T]>;
     keys(): IterableIterator<T>;
     values(): IterableIterator<T>;

package/dist/types/observablevalue.d.ts

@@ -9,21 +9,19 @@ export declare type IValueDidChange<T = any> = {
     observableKind: "value";
     object: IObservableValue<T>;
     debugObjectName: string;
-    newValue: unknown;
-    oldValue: unknown;
+    newValue: T;
+    oldValue: T | undefined;
 };
 export declare type IBoxDidChange<T = any> = {
     type: "create";
     observableKind: "value";
     object: IObservableValue<T>;
     debugObjectName: string;
-    newValue: unknown;
+    newValue: T;
 } | IValueDidChange<T>;
 export interface IObservableValue<T> {
     get(): T;
     set(value: T): void;
-    intercept_(handler: IInterceptor<IValueWillChange<T>>): Lambda;
-    observe_(listener: (change: IValueDidChange<T>) => void, fireImmediately?: boolean): Lambda;
 }
 export declare class ObservableValue<T> extends Atom implements IObservableValue<T>, IInterceptable<IValueWillChange<T>>, IListenable {
     enhancer: IEnhancer<T>;

package/dist/utils/utils.d.ts

@@ -4,8 +4,8 @@ export declare const assign: {
     <T_2, U_2, V_1, W>(target: T_2, source1: U_2, source2: V_1, source3: W): T_2 & U_2 & V_1 & W;
     (target: object, ...sources: any[]): any;
 };
-export declare const getDescriptor: (o: any, p: string | number | symbol) => PropertyDescriptor | undefined;
-export declare const defineProperty: (o: any, p: string | number | symbol, attributes: PropertyDescriptor & ThisType<any>) => any;
+export declare const getDescriptor: (o: any, p: PropertyKey) => PropertyDescriptor | undefined;
+export declare const defineProperty: <T>(o: T, p: PropertyKey, attributes: PropertyDescriptor & ThisType<any>) => T;
 export declare const objectPrototype: Object;
 export declare const EMPTY_ARRAY: never[];
 export declare const EMPTY_OBJECT: {};
@@ -30,13 +30,13 @@ export declare function isGenerator(obj: any): boolean;
 export declare function addHiddenProp(object: any, propName: PropertyKey, value: any): void;
 export declare function addHiddenFinalProp(object: any, propName: PropertyKey, value: any): void;
 export declare function createInstanceofPredicate<T>(name: string, theClass: new (...args: any[]) => T): (x: any) => x is T;
-export declare function isES6Map(thing: any): boolean;
+export declare function isES6Map(thing: any): thing is Map<any, any>;
 export declare function isES6Set(thing: any): thing is Set<any>;
 /**
  * Returns the following: own enumerable keys and symbols.
  */
 export declare function getPlainObjectKeys(object: any): (string | symbol)[];
-export declare const ownKeys: (target: any) => PropertyKey[];
+export declare const ownKeys: (target: any) => Array<string | symbol>;
 export declare function stringifyKey(key: any): string;
 export declare function toPrimitive(value: any): any;
 export declare function hasProp(target: Object, prop: PropertyKey): boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "mobx",
-    "version": "6.1.8",
+    "version": "6.9.0",
     "description": "Simple, scalable state management.",
     "source": "src/mobx.ts",
     "main": "dist/index.js",

package/src/api/action.ts

@@ -45,10 +45,13 @@ export interface IActionFactory extends Annotation, PropertyDecorator {
 function createActionFactory(autoAction: boolean): IActionFactory {
     const res: IActionFactory = function action(arg1, arg2?): any {
         // action(fn() {})
-        if (isFunction(arg1))
+        if (isFunction(arg1)) {
             return createAction(arg1.name || DEFAULT_ACTION_NAME, arg1, autoAction)
+        }
         // action("name", fn() {})
-        if (isFunction(arg2)) return createAction(arg1, arg2, autoAction)
+        if (isFunction(arg2)) {
+            return createAction(arg1, arg2, autoAction)
+        }
         // @action
         if (isStringish(arg2)) {
             return storeAnnotation(arg1, arg2, autoAction ? autoActionAnnotation : actionAnnotation)
@@ -63,7 +66,9 @@ function createActionFactory(autoAction: boolean): IActionFactory {
             )
         }
 
-        if (__DEV__) die("Invalid arguments for `action`")
+        if (__DEV__) {
+            die("Invalid arguments for `action`")
+        }
     } as IActionFactory
     return res
 }

package/src/api/annotation.ts

@@ -1,17 +1,19 @@
-import {
-    ObservableObjectAdministration,
-    isGenerator,
-    isFunction,
-    autoAction,
-    isAction,
-    flow,
-    computed,
-    isFlow
-} from "../internal"
+import { ObservableObjectAdministration, isFunction } from "../internal"
+
+export const enum MakeResult {
+    Cancel,
+    Break,
+    Continue
+}
 
 export type Annotation = {
     annotationType_: string
-    make_(adm: ObservableObjectAdministration, key: PropertyKey): void
+    make_(
+        adm: ObservableObjectAdministration,
+        key: PropertyKey,
+        descriptor: PropertyDescriptor,
+        source: object
+    ): MakeResult
     extend_(
         adm: ObservableObjectAdministration,
         key: PropertyKey,
@@ -30,39 +32,7 @@ export type AnnotationMapEntry =
 // declare annotations for private/ protected members, see #2339
 export type AnnotationsMap<T, AdditionalFields extends PropertyKey> = {
     [P in Exclude<keyof T, "toString">]?: AnnotationMapEntry
-} &
-    Record<AdditionalFields, AnnotationMapEntry>
-
-/**
- * Infers the best fitting annotation from property descriptor or false if the field shoudn't be annotated
- * - getter(+setter) -> computed
- * - setter w/o getter -> false (ignore)
- * - flow -> false (ignore)
- * - generator -> flow
- * - action -> false (ignore)
- * - function -> action (optionally bound)
- * - other -> defaultAnnotation
- */
-export function inferAnnotationFromDescriptor(
-    desc: PropertyDescriptor,
-    defaultAnnotation: Annotation,
-    autoBind: boolean
-): Annotation | false {
-    if (desc.get) return computed
-    if (desc.set) return false // ignore lone setter
-    // If already wrapped in action/flow, don't do that another time, but assume it is already set up properly.
-    return isFunction(desc.value)
-        ? isGenerator(desc.value)
-            ? isFlow(desc.value)
-                ? false
-                : flow
-            : isAction(desc.value)
-            ? false
-            : autoBind
-            ? autoAction.bound
-            : autoAction
-        : defaultAnnotation
-}
+} & Record<AdditionalFields, AnnotationMapEntry>
 
 export function isAnnotation(thing: any) {
     return (

package/src/api/autorun.ts

@@ -38,8 +38,12 @@ export function autorun(
     opts: IAutorunOptions = EMPTY_OBJECT
 ): IReactionDisposer {
     if (__DEV__) {
-        if (!isFunction(view)) die("Autorun expects a function as first argument")
-        if (isAction(view)) die("Autorun does not accept actions since actions are untrackable")
+        if (!isFunction(view)) {
+            die("Autorun expects a function as first argument")
+        }
+        if (isAction(view)) {
+            die("Autorun does not accept actions since actions are untrackable")
+        }
     }
 
     const name: string =
@@ -69,7 +73,9 @@ export function autorun(
                     isScheduled = true
                     scheduler(() => {
                         isScheduled = false
-                        if (!reaction.isDisposed_) reaction.track(reactionRunner)
+                        if (!reaction.isDisposed_) {
+                            reaction.track(reactionRunner)
+                        }
                     })
                 }
             },
@@ -86,14 +92,14 @@ export function autorun(
     return reaction.getDisposer_()
 }
 
-export type IReactionOptions = IAutorunOptions & {
-    fireImmediately?: boolean
-    equals?: IEqualsComparer<any>
+export type IReactionOptions<T, FireImmediately extends boolean> = IAutorunOptions & {
+    fireImmediately?: FireImmediately
+    equals?: IEqualsComparer<T>
 }
 
 const run = (f: Lambda) => f()
 
-function createSchedulerFromOptions(opts: IReactionOptions) {
+function createSchedulerFromOptions(opts: IAutorunOptions) {
     return opts.scheduler
         ? opts.scheduler
         : opts.delay
@@ -101,15 +107,22 @@ function createSchedulerFromOptions(opts: IReactionOptions) {
         : run
 }
 
-export function reaction<T>(
+export function reaction<T, FireImmediately extends boolean = false>(
     expression: (r: IReactionPublic) => T,
-    effect: (arg: T, prev: T, r: IReactionPublic) => void,
-    opts: IReactionOptions = EMPTY_OBJECT
+    effect: (
+        arg: T,
+        prev: FireImmediately extends true ? T | undefined : T,
+        r: IReactionPublic
+    ) => void,
+    opts: IReactionOptions<T, FireImmediately> = EMPTY_OBJECT
 ): IReactionDisposer {
     if (__DEV__) {
-        if (!isFunction(expression) || !isFunction(effect))
+        if (!isFunction(expression) || !isFunction(effect)) {
             die("First and second argument to reaction should be functions")
-        if (!isPlainObject(opts)) die("Third argument of reactions should be an object")
+        }
+        if (!isPlainObject(opts)) {
+            die("Third argument of reactions should be an object")
+        }
     }
     const name = opts.name ?? (__DEV__ ? "Reaction@" + getNextId() : "Reaction")
     const effectAction = action(
@@ -122,9 +135,9 @@ export function reaction<T>(
     let firstTime = true
     let isScheduled = false
     let value: T
-    let oldValue: T = undefined as any // only an issue with fireImmediately
+    let oldValue: T | undefined
 
-    const equals = (opts as any).compareStructural
+    const equals: IEqualsComparer<T> = (opts as any).compareStructural
         ? comparer.structural
         : opts.equals || comparer.default
 
@@ -144,7 +157,9 @@ export function reaction<T>(
 
     function reactionRunner() {
         isScheduled = false
-        if (r.isDisposed_) return
+        if (r.isDisposed_) {
+            return
+        }
         let changed: boolean = false
         r.track(() => {
             const nextValue = allowStateChanges(false, () => expression(r))
@@ -152,8 +167,14 @@ export function reaction<T>(
             oldValue = value
             value = nextValue
         })
-        if (firstTime && opts.fireImmediately!) effectAction(value, oldValue, r)
-        else if (!firstTime && changed) effectAction(value, oldValue, r)
+
+        // This casting is nesessary as TS cannot infer proper type in current funciton implementation
+        type OldValue = FireImmediately extends true ? T | undefined : T
+        if (firstTime && opts.fireImmediately!) {
+            effectAction(value, oldValue as OldValue, r)
+        } else if (!firstTime && changed) {
+            effectAction(value, oldValue as OldValue, r)
+        }
         firstTime = false
     }
 

package/src/api/computed.ts

@@ -46,11 +46,14 @@ export const computed: IComputedFactory = function computed(arg1, arg2) {
 
     // computed(expr, options?)
     if (__DEV__) {
-        if (!isFunction(arg1)) die("First argument to `computed` should be an expression.")
-        if (isFunction(arg2))
+        if (!isFunction(arg1)) {
+            die("First argument to `computed` should be an expression.")
+        }
+        if (isFunction(arg2)) {
             die(
                 "A setter as second argument is no longer supported, use `{ set: fn }` option instead"
             )
+        }
     }
     const opts: IComputedValueOptions<any> = isPlainObject(arg2) ? arg2 : {}
     opts.get = arg1

package/src/api/configure.ts

@@ -34,7 +34,9 @@ export function configure(options: {
                 ? false
                 : typeof Proxy !== "undefined"
     }
-    if (useProxies === "ifavailable") globalState.verifyProxies = true
+    if (useProxies === "ifavailable") {
+        globalState.verifyProxies = true
+    }
     if (enforceActions !== undefined) {
         const ea = enforceActions === ALWAYS ? ALWAYS : enforceActions === OBSERVED
         globalState.enforceActions = ea
@@ -47,7 +49,9 @@ export function configure(options: {
         "disableErrorBoundaries",
         "safeDescriptors"
     ].forEach(key => {
-        if (key in options) globalState[key] = !!options[key]
+        if (key in options) {
+            globalState[key] = !!options[key]
+        }
     })
     globalState.allowStateReads = !globalState.observableRequiresReaction
     if (__DEV__ && globalState.disableErrorBoundaries === true) {

package/src/api/decorators.ts

@@ -51,7 +51,7 @@ function assertNotDecorated(prototype: object, annotation: Annotation, key: Prop
             `Cannot apply '@${requestedAnnotationType}' to '${fieldName}':` +
                 `\nThe field is already decorated with '@${currentAnnotationType}'.` +
                 `\nRe-decorating fields is not allowed.` +
-                `\nUse '@override' decorator for methods overriden by subclass.`
+                `\nUse '@override' decorator for methods overridden by subclass.`
         )
     }
 }

package/src/api/extendobservable.ts

@@ -21,15 +21,21 @@ export function extendObservable<A extends Object, B extends Object>(
     options?: CreateObservableOptions
 ): A & B {
     if (__DEV__) {
-        if (arguments.length > 4) die("'extendObservable' expected 2-4 arguments")
-        if (typeof target !== "object")
+        if (arguments.length > 4) {
+            die("'extendObservable' expected 2-4 arguments")
+        }
+        if (typeof target !== "object") {
             die("'extendObservable' expects an object as first argument")
-        if (isObservableMap(target))
+        }
+        if (isObservableMap(target)) {
             die("'extendObservable' should not be used on maps, use map.merge instead")
-        if (!isPlainObject(properties))
-            die(`'extendObservabe' only accepts plain objects as second argument`)
-        if (isObservable(properties) || isObservable(annotations))
+        }
+        if (!isPlainObject(properties)) {
+            die(`'extendObservable' only accepts plain objects as second argument`)
+        }
+        if (isObservable(properties) || isObservable(annotations)) {
             die(`Extending an object with another observable (object) is not supported`)
+        }
     }
     // Pull descriptors first, so we don't have to deal with props added by administration ($mobx)
     const descriptors = getOwnPropertyDescriptors(properties)

package/src/api/extras.ts

@@ -18,8 +18,9 @@ function nodeToDependencyTree(node: IDepTreeNode): IDependencyTree {
     const result: IDependencyTree = {
         name: node.name_
     }
-    if (node.observing_ && node.observing_.length > 0)
+    if (node.observing_ && node.observing_.length > 0) {
         result.dependencies = unique(node.observing_).map(nodeToDependencyTree)
+    }
     return result
 }
 
@@ -31,8 +32,9 @@ function nodeToObserverTree(node: IDepTreeNode): IObserverTree {
     const result: IObserverTree = {
         name: node.name_
     }
-    if (hasObservers(node as any))
+    if (hasObservers(node as any)) {
         result.observers = Array.from(<any>getObservers(node as any)).map(<any>nodeToObserverTree)
+    }
     return result
 }
 

package/src/api/flow.ts

@@ -6,7 +6,8 @@ import {
     Annotation,
     isStringish,
     storeAnnotation,
-    createFlowAnnotation
+    createFlowAnnotation,
+    createDecoratorAnnotation
 } from "../internal"
 
 export const FLOW = "flow"
@@ -28,9 +29,11 @@ interface Flow extends Annotation, PropertyDecorator {
     <R, Args extends any[]>(
         generator: (...args: Args) => Generator<any, R, any> | AsyncGenerator<any, R, any>
     ): (...args: Args) => CancellablePromise<R>
+    bound: Annotation & PropertyDecorator
 }
 
 const flowAnnotation = createFlowAnnotation("flow")
+const flowBoundAnnotation = createFlowAnnotation("flow.bound", { bound: true })
 
 export const flow: Flow = Object.assign(
     function flow(arg1, arg2?) {
@@ -39,8 +42,9 @@ export const flow: Flow = Object.assign(
             return storeAnnotation(arg1, arg2, flowAnnotation)
         }
         // flow(fn)
-        if (__DEV__ && arguments.length !== 1)
+        if (__DEV__ && arguments.length !== 1) {
             die(`Flow expects single argument with generator function`)
+        }
         const generator = arg1
         const name = generator.name || "<unnamed flow>"
 
@@ -92,7 +96,9 @@ export const flow: Flow = Object.assign(
                         ret.then(next, reject)
                         return
                     }
-                    if (ret.done) return resolve(ret.value)
+                    if (ret.done) {
+                        return resolve(ret.value)
+                    }
                     pendingPromise = Promise.resolve(ret.value) as any
                     return pendingPromise!.then(onFulfilled, onRejected)
                 }
@@ -102,7 +108,9 @@ export const flow: Flow = Object.assign(
 
             promise.cancel = action(`${name} - runid: ${runId} - cancel`, function () {
                 try {
-                    if (pendingPromise) cancelPromise(pendingPromise)
+                    if (pendingPromise) {
+                        cancelPromise(pendingPromise)
+                    }
                     // Finally block can return (or yield) stuff..
                     const res = gen.return!(undefined as any)
                     // eat anything that promise would do, it's cancelled!
@@ -123,8 +131,12 @@ export const flow: Flow = Object.assign(
     flowAnnotation
 )
 
+flow.bound = createDecoratorAnnotation(flowBoundAnnotation)
+
 function cancelPromise(promise) {
-    if (isFunction(promise.cancel)) promise.cancel()
+    if (isFunction(promise.cancel)) {
+        promise.cancel()
+    }
 }
 
 export function flowResult<T>(

package/src/api/intercept-read.ts

@@ -39,16 +39,18 @@ export function interceptReads(thing, propOrHandler?, handler?): Lambda {
     if (isObservableMap(thing) || isObservableArray(thing) || isObservableValue(thing)) {
         target = getAdministration(thing)
     } else if (isObservableObject(thing)) {
-        if (__DEV__ && !isStringish(propOrHandler))
+        if (__DEV__ && !isStringish(propOrHandler)) {
             return die(
                 `InterceptReads can only be used with a specific property, not with an object in general`
             )
+        }
         target = getAdministration(thing, propOrHandler)
     } else if (__DEV__) {
         return die(`Expected observable map, object or array as first array`)
     }
-    if (__DEV__ && target.dehancer !== undefined)
+    if (__DEV__ && target.dehancer !== undefined) {
         return die(`An intercept reader was already established`)
+    }
     target.dehancer = typeof propOrHandler === "function" ? propOrHandler : handler
     return () => {
         target.dehancer = undefined

package/src/api/intercept.ts

@@ -20,19 +20,19 @@ export function intercept<T>(
     handler: IInterceptor<IValueWillChange<T>>
 ): Lambda
 export function intercept<T>(
-    observableArray: IObservableArray<T>,
+    observableArray: IObservableArray<T> | Array<T>,
     handler: IInterceptor<IArrayWillChange<T> | IArrayWillSplice<T>>
 ): Lambda
 export function intercept<K, V>(
-    observableMap: ObservableMap<K, V>,
+    observableMap: ObservableMap<K, V> | Map<K, V>,
     handler: IInterceptor<IMapWillChange<K, V>>
 ): Lambda
 export function intercept<V>(
-    observableMap: ObservableSet<V>,
+    observableSet: ObservableSet<V> | Set<V>,
     handler: IInterceptor<ISetWillChange<V>>
 ): Lambda
 export function intercept<K, V>(
-    observableMap: ObservableMap<K, V>,
+    observableMap: ObservableMap<K, V> | Map<K, V>,
     property: K,
     handler: IInterceptor<IValueWillChange<V>>
 ): Lambda
@@ -40,11 +40,14 @@ export function intercept(object: object, handler: IInterceptor<IObjectWillChang
 export function intercept<T extends object, K extends keyof T>(
     object: T,
     property: K,
-    handler: IInterceptor<IValueWillChange<any>>
+    handler: IInterceptor<IValueWillChange<T[K]>>
 ): Lambda
 export function intercept(thing, propOrHandler?, handler?): Lambda {
-    if (isFunction(handler)) return interceptProperty(thing, propOrHandler, handler)
-    else return interceptInterceptable(thing, propOrHandler)
+    if (isFunction(handler)) {
+        return interceptProperty(thing, propOrHandler, handler)
+    } else {
+        return interceptInterceptable(thing, propOrHandler)
+    }
 }
 
 function interceptInterceptable(thing, handler) {