hunk.code_window:     // @action.bound decorator
       bound(target: Object, propertyKey: string, descriptor?: PropertyDescriptor): void
   }
   export var action: IActionFactory = function action(arg1, arg2?, arg3?, arg4?): any {
       // action(fn() {})
  
hunk.labels: keep keep replace keep keep keep keep
hunk.after_edit:     bound(target: Object, propertyKey: string | symbol, descriptor?: PropertyDescriptor): void
  
hunk.file_path: src/api/action.ts
hunk.type: replace
file: import {
      BabelDescriptor,
      IEnhancer,
      asObservableObject,
      createPropDecorator,
      fail,
      invariant
  } from "../internal"
  
  export type IObservableDecorator = {
      (target: Object, property: string, descriptor?: PropertyDescriptor): void
      enhancer: IEnhancer<any>
  }
  
  export function createDecoratorForEnhancer(enhancer: IEnhancer<any>): IObservableDecorator {
      invariant(enhancer)
      const decorator = createPropDecorator(
          true,
          (
              target: any,
              propertyName: string,
              descriptor: BabelDescriptor | undefined,
              _decoratorTarget,
              decoratorArgs: any[]
          ) => {
              if (process.env.NODE_ENV !== "production") {
                  invariant(
                      !descriptor || !descriptor.get,
                      `@observable cannot be used on getter (property "${propertyName}"), use @computed instead.`
                  )
              }
              const initialValue = descriptor
                  ? descriptor.initializer
                      ? descriptor.initializer.call(target)
                      : descriptor.value
                  : undefined
              asObservableObject(target).addObservableProp(propertyName, initialValue, enhancer)
          }
      )
      const res: any =
          // Extra process checks, as this happens during module initialization
          typeof process !== "undefined" && process.env && process.env.NODE_ENV !== "production"
              ? function observableDecorator() {
                    // This wrapper function is just to detect illegal decorator invocations, deprecate in a next version
                    // and simply return the created prop decorator
                    if (arguments.length < 2)
                        return fail(
                            "Incorrect decorator invocation. @observable decorator doesn't expect any arguments"
                        )
                    return decorator.apply(null, arguments)
                }
              : decorator
      res.enhancer = enhancer
      return res
  }
  