JavaScriptExpert
diff --git a/‎src/api/action.ts‎
Lines changed: 16 additions & 4 deletions b/‎src/api/action.ts‎
Lines changed: 16 additions & 4 deletions
diff --git a/‎test/base/action.js‎
Lines changed: 49 additions & 0 deletions b/‎test/base/action.js‎
Lines changed: 49 additions & 0 deletions
@@ -66,8 +66,11 @@ function dontReassignFields() {
     invariant(false, process.env.NODE_ENV !== "production" && "@action fields are not reassignable")
 }
 
-const boundActionDecorator = function(target, propertyName, descriptor) {
-    debugger
+const boundActionDecorator = function(target, propertyName, descriptor, applyToInstance?: boolean) {
+    if (applyToInstance === true) {
+        defineBoundAction(this, propertyName, descriptor.value)
+        return null
+    }
     if (descriptor) {
         if (descriptor.value)
             // Typescript / Babel: @action.bound method() { }
@@ -104,14 +107,23 @@ const boundActionDecorator = function(target, propertyName, descriptor) {
 }
 
 export var action: IActionFactory = function action(arg1, arg2?, arg3?, arg4?): any {
-    debugger
     if (arguments.length === 1 && typeof arg1 === "function")
         return createAction(arg1.name || "<unnamed action>", arg1)
     if (arguments.length === 2 && typeof arg2 === "function") return createAction(arg1, arg2)
 
     if (arguments.length === 1 && typeof arg1 === "string") return namedActionDecorator(arg1)
 
-    return namedActionDecorator(arg2).apply(null, arguments)
+    if (arg4 === true) {
+        // apply to instance immediately
+        return {
+            value: createAction(name, arg3.value),
+            enumerable: false,
+            configurable: false,
+            writable: false
+        }
+    } else {
+        return namedActionDecorator(arg2).apply(null, arguments)
+    }
 } as any
 
 action.bound = boundActionDecorator as any
 
@@ -372,6 +372,55 @@ test("computed values and actions", () => {
     expect(calls).toBe(3)
 })
 
+test("extendObservable respects action decorators", () => {
+    debugger
+    const x = mobx.observable.object(
+        // TODO remove .object
+        {
+            a1() {
+                return this
+            },
+            a2() {
+                return this
+            },
+            a3() {
+                return this
+            }
+        },
+        {
+            a1: mobx.action,
+            a2: mobx.action.bound
+        }
+    )
+    expect(mobx.isAction(x.a1)).toBe(true)
+    expect(mobx.isAction(x.a2)).toBe(true)
+    expect(mobx.isAction(x.a3)).toBe(false)
+
+    const global = (function() {
+        return this
+    })()
+
+    const { a1, a2, a3 } = x
+    expect(a1.call(x)).toBe(x)
+    // expect(a1()).toBe(global)
+    expect(a2.call(x)).toBe(x)
+    expect(a2()).toBe(x)
+    expect(a3.call(x)).toBe(x)
+    // expect(a3()).toBe(global)
+})
+
+test("expect warning for invalid decorator", () => {
+    expect(() => {
+        mobx.observable({ x: 1 }, { x: undefined })
+    }).toThrow(/Not a valid decorator for 'x', got: undefined/)
+})
+
+test("expect warning superfluos decorator", () => {
+    expect(() => {
+        mobx.observable({ x() {} }, { y: mobx.action })
+    }).toThrow(/Not a valid decorator for 'x', got: undefined/)
+})
+
 // TODO re-enable
 test.skip("bound actions bind", () => {
     var called = 0