shared/util/debug.tsx - master - githubmirror/client

shared/util/debug.tsx
72 строки2 KB
chrisnojima
move to vite (#29386)
09 июл 2026, 00:46
09 июл 2026, 00:46bcd1945
import logger from '@/logger'

// helper to debug method calls into an object
export function createLoggingProxy<T extends {[key: string]: unknown}>(
  obj: T,
  logMethods: boolean = true,
  logProps: boolean = false
): T {
  console.log('[PROXY] installed!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!')
  const cache = new Map<string, unknown>()
  const proxy = new Proxy(
    {},
    {
      get(_target, propKey: string) {
        if (cache.get(propKey)) {
          return cache.get(propKey)
        }
        const originalMethod: unknown = obj[propKey]
        if (typeof originalMethod === 'function') {
          if (logMethods) {
            const ret = function (...args: Array<unknown>) {
              console.log(`[PROXY] Calling method: ${String(propKey)}`)
              console.log('[PROXY] Arguments:', args)
              const result = originalMethod.apply(obj, args) as unknown
              console.log('[PROXY] Result:', result)
              return result
            }
            cache.set(propKey, ret)
            return ret
          } else {
            return originalMethod
          }
        } else {
          if (logProps) {
            console.log(`[PROXY] props access: ${String(propKey)}`)
          }
          return originalMethod
        }
      },
    }
  )

  return proxy as T
}

export function wrapErrors<T extends (...args: any[]) => any>(f: T, logExtra: string = ''): T {
  return ((...p: Parameters<T>): ReturnType<T> => {
    try {
      const result = f(...p) as unknown
      if (result instanceof Promise) {
         
        return result.catch((e: unknown) => {
          if (__DEV__) {
            logger.error('Error in wrapped call', logExtra, e)
          } else {
            logger.error('Error in wrapped call', logExtra)
          }
          throw e
        }) as ReturnType<T>
      }
       
      return result as ReturnType<T>
    } catch (e) {
      if (__DEV__) {
        logger.error('Error in wrapped call', logExtra, e)
      } else {
        logger.error('Error in wrapped call', logExtra)
      }
      throw e
    }
  }) as T
}