@codeleap/logger 5.0.10 → 5.0.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codeleap/logger",
-  "version": "5.0.10",
+  "version": "5.0.12",
   "main": "src/index.ts",
   "license": "UNLICENSED",
   "repository": {
@@ -9,9 +9,9 @@
     "directory": "packages/logger"
   },
   "devDependencies": {
-    "@codeleap/types": "5.0.10",
-    "@codeleap/utils": "5.0.10",
-    "@codeleap/config": "5.0.10",
+    "@codeleap/types": "5.0.12",
+    "@codeleap/utils": "5.0.12",
+    "@codeleap/config": "5.0.12",
     "ts-node-dev": "1.1.8",
     "@sentry/types": "8.40.0"
   },
@@ -19,8 +19,8 @@
     "build": "echo 'No build needed'"
   },
   "peerDependencies": {
-    "@codeleap/types": "5.0.10",
-    "@codeleap/utils": "5.0.10",
+    "@codeleap/types": "5.0.12",
+    "@codeleap/utils": "5.0.12",
     "typescript": "5.5.2",
     "react": "18.2.0"
   },

package/package.json.bak

@@ -1,6 +1,6 @@
 {
   "name": "@codeleap/logger",
-  "version": "5.0.10",
+  "version": "5.0.12",
   "main": "src/index.ts",
   "license": "UNLICENSED",
   "repository": {

package/src/index.ts

@@ -1,5 +1,2 @@
-export * as LoggerTypes from './types'
-export * as LoggerAnalytics from './Analytics'
-export * from './Logger'
-export * from './silentLogger'
-export * from './performance'
+export * from './lib'
+export * from './types'

package/src/lib/Logger.ts

@@ -0,0 +1,72 @@
+import { LoggerConfig } from '../types'
+import { SentryService } from './Sentry'
+import { SlackService } from './Slack'
+import { PerformanceService } from './performance'
+
+export class Logger {
+  static initialized = false
+
+  private config: LoggerConfig
+
+  slack: SlackService
+
+  sentry: SentryService
+
+  perf: PerformanceService
+
+  private overrideConsoleMethod(args: unknown[], originalConsole: Console['log']) {
+    if (!Logger.initialized) return
+
+    const ignoreLogs = this.config.Logger.ignoreLogs
+    const shouldIgnore = typeof args[0] === 'string' && ignoreLogs.some(ignoredWarning => args.join(' ').includes(ignoredWarning))
+
+    if (shouldIgnore) return
+
+    return originalConsole.apply(console, args)
+  }
+
+  constructor() {
+    const consoles = ['log', 'warn', 'error']
+
+    consoles.forEach(level => {
+      const consoleRef = console[level]
+      console[level] = (...args: unknown[]) => this.overrideConsoleMethod(args, consoleRef)
+    })
+  }
+
+  initialize<T extends LoggerConfig>(config: T) {
+    if (Logger.initialized) return
+
+    this.config = config
+
+    this.sentry = new SentryService(config)
+
+    this.slack = new SlackService(config)
+
+    this.perf = new PerformanceService(config)
+
+    Logger.initialized = true
+  }
+
+  info(...args: unknown[]) {
+    throw new Error('Logger: implement the method "info"')
+  }
+
+  error(...args: unknown[]) {
+    throw new Error('Logger: implement the method "error"')
+  }
+
+  warn(...args: unknown[]) {
+    throw new Error('Logger: implement the method "warn"')
+  }
+
+  log(...args: unknown[]) {
+    throw new Error('Logger: implement the method "log"')
+  }
+
+  debug(...args: unknown[]) {
+    throw new Error('Logger: implement the method "debug"')
+  }
+}
+
+export const logger = new Logger()

package/src/lib/Sentry.ts

@@ -0,0 +1,62 @@
+import type { Breadcrumb, ClientOptions, SeverityLevel, Client } from '@sentry/types'
+import { LoggerConfig } from '../types'
+
+const SentrySeverityMap: Record<string, SeverityLevel> = {
+  debug: 'debug',
+  error: 'error',
+  info: 'info',
+  log: 'log',
+  warn: 'warning',
+  silent: 'log',
+}
+
+type SentryProvider = {
+  addBreadcrumb: (args: Breadcrumb) => void
+  init(options: ClientOptions): Client
+  captureException(err: any): void
+}
+
+export class SentryService {
+  get provider(): SentryProvider {
+    return this.config.Sentry.provider
+  }
+
+  private get enabled() {
+    return this.config.Sentry.enabled
+  }
+
+  constructor(private config: LoggerConfig) {
+    if (config.Sentry.enabled) {
+      const initOptions: ClientOptions = {
+        dsn: config.Sentry.dsn,
+        debug: config.Sentry.debug,
+        beforeBreadcrumb: config.Sentry.beforeBreadcrumb,
+        integrations: [],
+        enabled: this.enabled,
+        ...config.Sentry.initArgs,
+      }
+
+      this.provider?.init?.(initOptions)
+    }
+  }
+
+  captureBreadcrumb(type: string, msg: string, data: any, category = `logger:${type}`) {
+    if (!this.enabled) return
+
+    const sentryArgs: Breadcrumb = {
+      message: msg,
+      data,
+      category,
+      level: SentrySeverityMap[type],
+      type: '',
+    }
+
+    this.provider.addBreadcrumb(sentryArgs)
+  }
+
+  captureException(err: any) {
+    if (!this.enabled) return
+
+    this.provider.captureException(err)
+  }
+}

package/src/{Slack.ts → lib/Slack.ts}

@@ -1,7 +1,6 @@
 import { inspect } from 'util'
-import { TypeGuards, AppSettings } from '@codeleap/types'
-
-type EchoSlackConfig = AppSettings['Slack']['echo']
+import { TypeGuards } from '@codeleap/types'
+import { LoggerConfig } from '../types'
 
 type EchoSlack = {
   label: string
@@ -20,21 +19,26 @@ type EchoSlackOptions = {
 }
 
 const DEFAULT_CHANNEL = '#_dev_logs'
+
 const DEFAULT_BASE_URL = 'https://slack.com/api/chat.postMessage'
 
 export class SlackService {
-  private echoConfig: EchoSlackConfig
+  private echoConfig: LoggerConfig['Slack']['echo']
 
-  private isDev: boolean
+  private isDev: LoggerConfig['Environment']['IsDev']
 
-  private appName: string
+  private appName: LoggerConfig['AppName']
 
-  public api
+  private api
 
-  constructor(settings: AppSettings) {
-    this.echoConfig = settings?.Slack?.echo as EchoSlackConfig
-    this.isDev = settings?.Environment?.IsDev
-    this.appName = settings?.AppName
+  constructor(private config: LoggerConfig) {
+    this.echoConfig = config.Slack.echo
+    this.isDev = config.Environment.IsDev
+    this.appName = config.AppName
+  }
+
+  setApi(fetcher: any) {
+    this.api = fetcher
   }
 
   async echo(
@@ -55,7 +59,7 @@ export class SlackService {
     try {
       const data = {
         'channel': this?.echoConfig?.channel ?? DEFAULT_CHANNEL,
-        text: slack,
+        'text': slack,
         'username': `${this.appName} Log`,
         'icon_url': this?.echoConfig?.icon,
         ...settingsData,
@@ -135,4 +139,4 @@ export class SlackService {
   
     return slack
   }
-}
+}

package/src/lib/index.ts

@@ -0,0 +1 @@
+export * from './Logger'

package/src/{performance → lib/performance}/errors.ts

@@ -1,4 +1,4 @@
-import { InspectRenderOptions } from '.'
+import { InspectRenderOptions } from './types'
 
 type ErrorArgs = InspectRenderOptions & {
   name: string
@@ -23,4 +23,4 @@ export class PerformanceError extends Error {
     super(defineError(errorName, args))
     this.name = 'Codeleap:Perf'
   }
-}
+}

package/src/lib/performance/index.ts

@@ -0,0 +1,79 @@
+import { throttle } from '@codeleap/utils'
+import { useEffect } from 'react'
+import { PerformanceError } from './errors'
+import { InspectRenderOptions } from './types'
+import { LoggerConfig } from '../../types'
+
+export * from './types'
+
+export class PerformanceService {
+  renderCounter: Record<string, number> = {}
+
+  constructor(private config: LoggerConfig) { }
+
+  /**
+  * inspectRender monitors how much time a component render per second.
+  * Use logger.perf.inspectRender('ComponentName') inside a component to monitor it.
+  * @param {string} name - Component name
+  * @param {PerformanceInspector} options - Some options for the inspector
+  * @returns
+  */
+  inspectRender = (
+    name: string,
+    options: InspectRenderOptions = {
+      noHooks: false,
+      logMode: 'summarized',
+      throttleInterval: 1000,
+    },
+  ) => {
+    const config = this.config.Logger.performanceInspector
+
+    const blacklist = config.blacklist || []
+
+    if (blacklist.some((item) => name.startsWith(item))) return
+
+    const { noHooks, logMode, throttleInterval, maxRenders = config.maxRenders } = options
+
+    if (!config.enabled || !this.config.Environment.IsDev) {
+      return
+    }
+
+    if (!noHooks) {
+      useEffect(() => {
+        console.log(`[PerformanceInspector] Mounted -> ${name}`)
+
+        return () => {
+          console.log(`[PerformanceInspector] Unmounted -> ${name}`)
+        }
+      })
+    }
+
+    this.renderCounter[name] = this.renderCounter[name] ? this.renderCounter[name] + 1 : 1
+    
+    const renders = this.renderCounter[name]
+
+    if (renders > maxRenders) {
+      this.renderCounter[name] = 0
+
+      throw new PerformanceError('maxRenders', {
+        name,
+        throttleInterval,
+        maxRenders,
+      })
+    }
+
+    if (logMode === 'raw') {
+      console.log(`[PerformanceInspector] Rendered -> ${name}: ${renders}`)
+      return
+    }
+
+    function logSummary() {
+      if (renders <= 0) return
+
+      console.log(`[PerformanceInspector] Render summary -> ${name}: ${renders}`)
+      this.renderCounter[name] = 0
+    }
+
+    throttle(logSummary, name, throttleInterval)
+  }
+}

package/src/lib/performance/types.ts

@@ -0,0 +1,6 @@
+export type InspectRenderOptions = {
+  noHooks?: boolean
+  logMode?: 'raw' | 'summarized'
+  throttleInterval?: number
+  maxRenders?: number
+}

package/src/types.ts

@@ -1,45 +1,38 @@
-import { FunctionType } from '@codeleap/types'
-import { colors, foregroundColors } from './constants'
 
-import type { SeverityLevel, Client, ClientOptions, Breadcrumb } from '@sentry/types'
+export type LoggerConfig = {
+  AppName: string
+  
+  Environment: {
+    IsDev: boolean
+  }
+  
+  Slack: {
+    echo: {
+      channel?: string
+      icon: string
+      token: string
+      baseURL?: string
+      enabled?: boolean
+      options?: Record<string, any>
+    }
+  }
 
-export type LogType = 'info' | 'debug' | 'warn' | 'error' | 'log' | 'silent'
+  Logger: {
+    ignoreLogs: string[]
 
-export type LogFunctionArgs = [
-    description?: any,
-    value?:any,
-    category?:string
-]
-export type ConsoleColor = keyof typeof colors
-export type DebugColors = {
-  [Property in keyof typeof foregroundColors as `${Lowercase<
-    string & Property
-  >}`]: (...args: LogFunctionArgs) => void;
-}
-export type DebugColor = keyof DebugColors
-export type LogToTerminalArgs = {
-  logType: LogType
-  args: LogFunctionArgs
-  color?: keyof DebugColors
-  deviceIdentifier?: string
-  stringify?: boolean
-  logKeys?: boolean
-}
-export type LogToTerminal = FunctionType<[LogToTerminalArgs], void>
+    performanceInspector: {
+      enabled: boolean
+      maxRenders: number
+      blacklist: string[]
+    }
+  }
 
-export const SentrySeverityMap: Record<LogType, SeverityLevel> = {
-  debug: 'debug',
-  error: 'error',
-  info: 'info',
-  log: 'log',
-  warn: 'warning',
-  silent: 'log',
-}
-
-export type SentryProvider = {
-  addBreadcrumb: FunctionType<[Breadcrumb], void>
-  init(options: ClientOptions): Client
-  captureException(err: any): void
-}
-
-export type LoggerMiddleware = FunctionType<[arguments: LogToTerminalArgs, formattedContent: string[]], any>
+  Sentry: {
+    enabled: boolean
+    dsn: string
+    provider: any
+    debug?: boolean
+    initArgs?: any
+    beforeBreadcrumb?: any
+  }
+}

package/src/Analytics.ts

@@ -1,67 +0,0 @@
-import { obfuscate } from './obfuscate'
-import { FunctionType, AnyFunction, AppSettings } from '@codeleap/types'
-
-export type AnalyticsObject = {
-  name: string
-  type: 'interaction' | 'event'
-  data: any
-}
-
-type IAnalyticsArgs = {
-  init(): any
-  prepareData: () => any
-  error?: (err: any) => any
-} & Record<`on${Capitalize<AnalyticsObject['type']>}`, FunctionType<[AnalyticsObject], void>>
-
-export class Analytics {
-
-  constructor(private callers: IAnalyticsArgs, private settings: AppSettings) {
-    this.callers.init()
-
-  }
-
-  private prepare() {
-    const data = this.callers.prepareData()
-
-    return data
-  }
-
-  obfuscate(data) {
-    return obfuscate({
-      object: data,
-      keys: this?.settings?.Logger?.Obfuscate?.keys || [],
-      values: this?.settings?.Logger?.Obfuscate?.values || [],
-    })
-  }
-
-  event(name: string, data = {}) {
-    this.handle(name, data, 'event', this.callers.onEvent)
-  }
-
-  interaction(name: string, data = {}) {
-    this.handle(name, data, 'interaction', this.callers.onInteraction)
-
-  }
-
-  onError(cb) {
-    this.callers.error = cb
-  }
-
-  private handle(name: string, data: any, type: AnalyticsObject['type'], fn: AnyFunction) {
-    try {
-
-      const obfuscated = this.obfuscate({
-        ...data,
-        ...this.prepare(),
-      })
-
-      fn({
-        name,
-        type,
-        data: obfuscated,
-      })
-    } catch (e) {
-      this.callers.error(e)
-    }
-  }
-}

package/src/Logger.ts

@@ -1,223 +0,0 @@
-import { inspect } from 'util'
-import { TypeGuards, LogType, AppSettings } from '@codeleap/types'
-import { Analytics } from './Analytics'
-import { SentryService } from './Sentry'
-import { SlackService } from './Slack'
-import { LogToTerminal, LogFunctionArgs, LogToTerminalArgs, LoggerMiddleware } from './types'
-
-const logLevels: LogType[] = ['debug', 'info', 'log', 'warn', 'error']
-
-const emptyFunction = () => { }
-
-const hollowAnalytics = new Analytics({
-  init: emptyFunction,
-  onEvent: emptyFunction,
-  onInteraction: emptyFunction,
-  prepareData: () => ({}),
-}, {})
-
-export class Logger {
-  static settings: AppSettings
-
-  settings: AppSettings
-
-  sentry: SentryService
-
-  slack: SlackService
-
-  middleware: LoggerMiddleware[] = []
-
-  constructor(settings: AppSettings, middleware?: LoggerMiddleware[], public analytics?: Analytics) {
-    this.settings = settings
-    this.middleware = middleware || []
-    if (settings.Logger.isMain) {
-      Logger.settings = settings
-    }
-
-    if (settings?.Logger?.IgnoreWarnings?.length) {
-      const newConsole = (args, oldConsole) => {
-        const shouldIgnore = typeof args[0] === 'string' &&
-          settings.Logger.IgnoreWarnings.some(ignoredWarning => args.join(' ').includes(ignoredWarning))
-        if (shouldIgnore) return
-        else return oldConsole.apply(console, args)
-      }
-      const consoles = ['log', 'warn', 'error']
-
-      consoles.forEach(t => {
-        const tmp = console[t]
-        console[t] = (...args) => newConsole(args, tmp)
-      })
-    }
-
-    this.sentry = new SentryService(settings)
-
-    this.slack = new SlackService(settings)
-
-    if (!analytics) {
-      this.analytics = hollowAnalytics
-    }
-
-    this.analytics.onError((err) => {
-      this.logToTerminal({
-        logType: 'error',
-        args: ['Error on analytics event', err, 'Internal'],
-      })
-    })
-
-  }
-
-  static formatContent(logArgs: LogToTerminalArgs) {
-    const { logType, args: content, deviceIdentifier: deviceId, stringify, logKeys = true } = logArgs
-
-    const [descriptionOrValue, value, category] = content
-
-    const nArgs = content.length
-    let logContent = content
-
-    const logValue = nArgs === 1 ? descriptionOrValue : value
-
-    const shouldStringify = stringify && !!logValue && TypeGuards.isObject(logValue) && !(logValue instanceof Error)
-    const inspectOptions = Logger?.settings?.Logger?.inspect || {}
-
-    const displayValue = shouldStringify ? inspect(logValue, {
-      depth: 5,
-      showHidden: true,
-      ...inspectOptions,
-    }) : logValue
-
-    if (nArgs === 3) {
-      logContent = [
-        `(${category}) ${descriptionOrValue}${displayValue ? ' ->' : ''}`,
-        displayValue,
-      ]
-    }
-
-    if (nArgs === 2) {
-      logContent = [
-        `${descriptionOrValue}${displayValue ? ' ->' : ''}`,
-        displayValue,
-      ]
-    }
-
-    if (nArgs === 1) {
-      const isObj = typeof descriptionOrValue === 'object' && !(descriptionOrValue instanceof Error)
-      const keys = isObj ? Object.keys(descriptionOrValue) : null
-      const title = isObj && keys.length && logKeys ?
-        `${keys.filter(i => !!i).slice(0, 3).join(', ')}${keys.length > 3 ? '...' : ''} ->`
-        : null
-
-      if (title) {
-        logContent = [
-          title,
-          displayValue,
-        ]
-      } else {
-        logContent = [
-          displayValue,
-        ]
-      }
-    }
-
-    return logContent
-  }
-
-  static coloredLog: LogToTerminal = (logArgs) => {
-    const { logType, args: content, deviceIdentifier: deviceId, stringify } = logArgs
-
-    const logContent = Logger.formatContent(logArgs)
-
-    const displayLog = logType === 'error' ? 'warn' : logType
-
-    console[displayLog](deviceId, ...logContent)
-
-    return logContent
-  }
-
-  private logToTerminal: LogToTerminal = (logArgs) => {
-    const { logType, args, color } = logArgs
-
-    if (this.settings.Logger.Level === 'silent') return
-
-    const shouldLog = TypeGuards.isString(this.settings.Logger.Level) ?
-      logLevels.indexOf(logType) >=
-      logLevels.indexOf(this.settings.Logger.Level) : this.settings.Logger.Level.includes(logType)
-    if (!shouldLog) return
-
-    const content = Logger.formatContent(logArgs)
-
-    if (this.settings.Environment.IsDev) {
-
-      const deviceId = this.settings.Logger?.DeviceIdentifier ?
-        `[${this.settings.Logger.DeviceIdentifier}]` : ''
-
-      const stringify = this.settings.Logger?.StringifyObjects
-
-      this.middleware.forEach(m => m(logArgs, content))
-
-      Logger.coloredLog(
-        {
-          logType: logType as LogType,
-          args,
-          color,
-          deviceIdentifier: deviceId,
-          stringify,
-        },
-      )
-
-    }
-
-    if (!this.settings.Environment.IsDev || this.settings.Logger.alwaysSendToSentry) {
-      try {
-
-        this.middleware.forEach(m => m(logArgs, content))
-        if (['info', 'log'].includes(logType)) {
-
-          this.sentry.captureBreadcrumb(
-            logType,
-            content,
-          )
-        }
-        if (['error'].includes(logType)) {
-          this.sentry.sendLog(args?.[1] || args?.[0])
-        }
-      } catch (e) {
-        // Nothing
-      }
-    }
-  }
-
-  info(...args: LogFunctionArgs) {
-    this.logToTerminal({
-      args,
-      logType: 'info',
-    })
-  }
-
-  error(...args: LogFunctionArgs) {
-    this.logToTerminal({
-      args,
-      logType: 'error',
-    })
-  }
-
-  warn(...args: LogFunctionArgs) {
-    this.logToTerminal({
-      args,
-      logType: 'warn',
-    })
-  }
-
-  log(...args: LogFunctionArgs) {
-    this.logToTerminal({
-      args,
-      logType: 'log',
-    })
-  }
-
-  debug(...args: LogFunctionArgs) {
-    this.logToTerminal({
-      args,
-      logType: 'debug',
-    })
-  }
-}

package/src/Sentry.ts

@@ -1,54 +0,0 @@
-import type { Breadcrumb, ClientOptions } from '@sentry/types'
-import { AppSettings } from '@codeleap/types'
-import {
-  LogFunctionArgs,
-  LogType,
-  SentrySeverityMap,
-  SentryProvider,
-} from './types'
-
-export class SentryService {
-  private sentry: SentryProvider
-
-  private use: boolean
-
-  constructor(settings: AppSettings) {
-    this.use = settings?.Sentry?.enable
-    this.sentry = settings?.Sentry?.provider as SentryProvider
-    if (this.use) {
-      const isDebug = settings?.Sentry?.debug || false
-      if (isDebug) console.log('> > > Initializing Sentry', settings.Sentry)
-      const initObj:ClientOptions = {
-        dsn: settings.Sentry.dsn,
-        debug: isDebug,
-        integrations: [],
-        ...settings?.Sentry?.initArgs,
-      }
-      if (settings?.Sentry?.beforeBreadcrumb) {
-        initObj.beforeBreadcrumb = settings?.Sentry?.beforeBreadcrumb
-      }
-      this.sentry?.init?.(initObj)
-    }
-  }
-
-  captureBreadcrumb(type: LogType, content: LogFunctionArgs) {
-    if (!this.use) return
-
-    const [message, data, category] = content
-
-    const sentryArgs: Breadcrumb = {
-      message,
-      data,
-      category,
-      level: SentrySeverityMap[type],
-      type: '',
-    }
-
-    this.sentry.addBreadcrumb(sentryArgs)
-  }
-
-  sendLog(err?: any) {
-    if (!this.use) return
-    this.sentry.captureException(err)
-  }
-}

package/src/constants.ts

@@ -1,37 +0,0 @@
-import { ConsoleColor } from './types'
-import { LogType } from '@codeleap/types'
-
-export const foregroundColors = {
-  Black: '\x1b[30m',
-  Red: '\x1b[31m',
-  Green: '\x1b[32m',
-  Yellow: '\x1b[33m',
-  Blue: '\x1b[34m',
-  Magenta: '\x1b[35m',
-  Cyan: '\x1b[36m',
-  White: '\x1b[37m',
-} as const
-
-export const formatColors = {
-  Reset: '\x1b[0m',
-  Bright: '\x1b[1m',
-  Dim: '\x1b[2m',
-  Underscore: '\x1b[4m',
-  Blink: '\x1b[5m',
-  Reverse: '\x1b[7m',
-  Hidden: '\x1b[8m',
-} as const
-
-export const colors = {
-  ...foregroundColors,
-  ...formatColors,
-}
-
-export const logColors: Record<LogType, ConsoleColor> = {
-  error: 'Red',
-  info: 'White',
-  warn: 'Yellow',
-  debug: 'Magenta',
-  log: 'White',
-  silent: 'Green',
-}

package/src/obfuscate.ts

@@ -1,76 +0,0 @@
-import { cloneDeep } from '@codeleap/utils'
-import { Matcher } from '@codeleap/types'
-import { inspect } from 'util'
-import parse from 'url-parse'
-
-type ObfuscateArgs = {
-  object: any
-  keys: (Matcher<'key'>)[]
-  values: (Matcher<'value'>)[]
-}
-
-function removeKey(obj, key) {
-  if (obj?.hasOwnProperty(key)) {
-    obj[key] = '[secret]'
-  }
-  for (const subObj in obj) {
-    if (typeof obj[subObj] == 'object') {
-      removeKey(obj[subObj], key)
-    }
-  }
-}
-
-function removeValue(obj, value) {
-  for (const subObj in obj) {
-    const isString = typeof obj[subObj] == 'string'
-    if (isString) {
-      const isRegex = value instanceof RegExp
-      const match = isRegex ? value.test(obj[subObj]) : obj[subObj].includes(value)
-      if (match) {
-        if (obj[subObj].startsWith('http')) {
-          const url = parse(obj[subObj])
-          obj[subObj] = `${url.origin}${url.pathname}/[secret]`
-        } else {
-          obj[subObj] = '[secret]'
-        }
-      }
-    }
-    if (typeof obj[subObj] == 'object') {
-      removeValue(obj[subObj], value)
-    }
-  }
-}
-
-export function obfuscate(args: ObfuscateArgs) {
-  const { object, keys, values } = args
-
-  let isCircular = false
-  try {
-    JSON.stringify(args)
-  } catch (e) {
-    isCircular = true
-  }
-
-  if (typeof object === 'object' && !isCircular) {
-    let cleanData = {}
-    try {
-      cleanData = cloneDeep(object)
-      keys.forEach(fieldName => removeKey(cleanData, fieldName))
-      values.forEach(fieldName => removeValue(cleanData, fieldName))
-    } catch (err1) {
-      try {
-        cleanData = inspect(object, { depth: 1 })
-      } catch (err2) {
-        cleanData = { value: `Couldn't process data` }
-      }
-    }
-    const result = cleanData
-    return result
-  } else {
-    if (isCircular) {
-      return { ...args.object, WARNING: 'Circular reference detected' }
-    } else {
-      return args.object
-    }
-  }
-}

package/src/performance/index.ts

@@ -1,86 +0,0 @@
-import { throttle } from '@codeleap/utils'
-import { useEffect } from 'react'
-import { AppSettings } from '@codeleap/types'
-import { PerformanceError } from './errors'
-
-export type InspectRenderOptions = {
-  noHooks?: boolean
-  logMode?: 'raw' | 'summarized'
-  throttleInterval?: number
-  maxRenders?: number
-}
-
-export type PerformanceInspector = {
-  inspectRender: (name: string, options?: InspectRenderOptions) => void
-}
-
-const renderCounter: Record<string, number> = {}
-
-export function makePerformanceInspector(settings: AppSettings) {
-  /**
-   * inspectRender monitors how much time a component render per second.
-   * Use perf.inspectRender('ComponentName') inside a component to monitor it.
-   * @param {string} name - Component name
-   * @param {PerformanceInspector} options - Some options for the inspector
-   * @returns
-   */
-  const inspectRender = (
-    name: string,
-    options: InspectRenderOptions = {
-      noHooks: false,
-      logMode: 'summarized',
-      throttleInterval: 1000,
-      maxRenders: settings?.PerformanceInspector.maxRenders,
-    },
-  ) => {
-    const blacklist = settings?.PerformanceInspector.blacklist || []
-    if (blacklist.some((item) => name.startsWith(item))) return
-
-    const { noHooks, logMode, throttleInterval, maxRenders } = options
-
-    if (
-      !settings?.PerformanceInspector.enable ||
-      !settings?.Environment.IsDev
-    ) {
-      return
-    }
-
-    if (!noHooks) {
-      useEffect(() => {
-        console.log(`[PerformanceInspector] Mounted -> ${name}`)
-
-        return () => {
-          console.log(`[PerformanceInspector] Unmounted -> ${name}`)
-        }
-      })
-    }
-
-    renderCounter[name] = renderCounter[name] ? renderCounter[name] + 1 : 1
-    const renders = renderCounter[name]
-
-    if (renders > maxRenders) {
-      renderCounter[name] = 0
-      throw new PerformanceError('maxRenders', {
-        name,
-        throttleInterval,
-        maxRenders,
-      })
-    }
-
-    if (logMode === 'raw') {
-      console.log(`[PerformanceInspector] Rendered -> ${name}: ${renders}`)
-      return
-    }
-
-    function logSummary() {
-      if (renders <= 0) return
-
-      console.log(`[PerformanceInspector] Render summary -> ${name}: ${renders}`)
-      renderCounter[name] = 0
-    }
-
-    throttle(logSummary, name, throttleInterval)
-  }
-
-  return { inspectRender }
-}

package/src/silentLogger.ts

@@ -1,11 +0,0 @@
-import { Logger } from './Logger'
-
-export const silentLogger = new Logger({
-  Logger: {
-    Level: 'silent',
-    IgnoreWarnings: [
-      `Require cycle:`,
-      `Require cycles are allowed`,
-    ],
-  },
-})