Method hook

scripts/libs/js-hook/index.js:342–399

* hook core function * @param parentObj {Object} - required The parent object that the hook function depends on * @param hookMethods {Object|Array|RegExp|string} - required The function name of the hooked function or the matching rule of the function name * @param fn {Function} -required

(parentObj, hookMethods, fn, type, classHook, context, proxyHandler)

    * @returns {boolean}
    */
  hook (parentObj, hookMethods, fn, type, classHook, context, proxyHandler) {
    /* Support parameter passing in object form */
    const opts = arguments[0]
    if (util.isObj(opts) && opts.parentObj && opts.hookMethods) {
      parentObj = opts.parentObj
      hookMethods = opts.hookMethods
      fn = opts.fn
      type = opts.type
      classHook = opts.classHook
      context = opts.context
      proxyHandler = opts.proxyHandler
    }

    classHook = toBoolean(classHook)
    type = type || 'before'

    if ((!util.isRef(parentObj) && !util.isFn(parentObj)) || !util.isFn(fn) || !hookMethods) {
      return false
    }

    const t = this

    hookMethods = t._getObjKeysByRule(parentObj, hookMethods)
    hookMethods.forEach(methodName => {
      if (!t.isAllowHook(parentObj, methodName)) {
        util.debug.log(`${util.toStr(parentObj)} [${methodName}] does not support modification`)
        return false
      }

      const descriptor = Object.getOwnPropertyDescriptor(parentObj, methodName)
      if (descriptor && descriptor.writable === false) {
        Object.defineProperty(parentObj, methodName, { writable: true })
      }

      const originMethod = parentObj[methodName]
      let hookMethod = null

      /* Non-functions cannot be hooked */
      if (!util.isFn(originMethod)) {
        return false
      }

      hookMethod = t._proxyMethodcGenerator(parentObj, methodName, originMethod, classHook, context, proxyHandler)

      const hookMethodProperties = hookMethod[t.hookPropertiesKeyName]
      if (hookMethodProperties.classHook !== classHook) {
        util.debug.log(`${util.toStr(parentObj)} [${methodName}] Cannot support functions hook and classes hook at the same time `)
        return false
      }

      /* Use hookMethod to take over the method that needs to be hooked */
      if (parentObj[methodName] !== hookMethod) {
        parentObj[methodName] = hookMethod
      }

      t._addHook(hookMethod, fn, type, classHook)
    })
  }