Remove workarounds for util in non-node environments (#359)

* Always use util.inspect.custom, rather than conditionally.

* Always use custom inspect.

* remove pointless custom inspect from memstore

* only use inspect symbol in cookie

* Add test for cookie custom inspect

lib/__tests__/cookieUtils.spec.ts

@@ -0,0 +1,17 @@
+import { inspect } from 'node:util'
+import { Cookie } from '../cookie/cookie'
+
+describe('Cookie utils', () => {
+  describe('custom inspect', () => {
+    it('should be a readable string', () => {
+      const cookie = new Cookie({
+        key: 'test',
+        value: 'b',
+        maxAge: 60,
+      })
+      expect(inspect(cookie)).toBe(
+        'Cookie="test=b; Max-Age=60; hostOnly=?; aAge=?; cAge=0ms"',
+      )
+    })
+  })
+})

lib/cookie/cookie.ts

@@ -34,7 +34,6 @@
 
 import { getPublicSuffix } from '../getPublicSuffix'
 import * as validators from '../validators'
-import { getCustomInspectSymbol } from '../utilHelper'
 import { inOperator } from '../utils'
 
 import { formatDate } from './formatDate'
@@ -421,17 +420,6 @@ export class Cookie {
   sameSite: string | undefined
 
   constructor(options: CreateCookieOptions = {}) {
-    // supports inspect if that feature is available in the environment
-    const customInspectSymbol = getCustomInspectSymbol()
-    if (customInspectSymbol) {
-      Object.defineProperty(this, customInspectSymbol, {
-        value: this.inspect.bind(this),
-        enumerable: false,
-        writable: false,
-        configurable: false,
-      })
-    }
-
     Object.assign(this, cookieDefaults, options)
     this.creation = options.creation ?? cookieDefaults.creation ?? new Date()
 
@@ -444,7 +432,7 @@ export class Cookie {
     })
   }
 
-  inspect() {
+  [Symbol.for('nodejs.util.inspect.custom')]() {
     const now = Date.now()
     const hostOnly = this.hostOnly != null ? this.hostOnly.toString() : '?'
     const createAge =

lib/memstore.ts

@@ -33,13 +33,7 @@ import type { Cookie } from './cookie/cookie'
 import { pathMatch } from './pathMatch'
 import { permuteDomain } from './permuteDomain'
 import { Store } from './store'
-import { getCustomInspectSymbol, getUtilInspect } from './utilHelper'
-import {
-  Callback,
-  createPromiseCallback,
-  inOperator,
-  ErrorCallback,
-} from './utils'
+import { Callback, createPromiseCallback, ErrorCallback } from './utils'
 
 export type MemoryCookieStoreIndex = {
   [domain: string]: {
@@ -57,20 +51,6 @@ export class MemoryCookieStore extends Store {
     super()
     this.synchronous = true
     this.idx = Object.create(null) as MemoryCookieStoreIndex
-    const customInspectSymbol = getCustomInspectSymbol()
-    if (customInspectSymbol) {
-      Object.defineProperty(this, customInspectSymbol, {
-        value: this.inspect.bind(this),
-        enumerable: false,
-        writable: false,
-        configurable: false,
-      })
-    }
-  }
-
-  inspect() {
-    const util = { inspect: getUtilInspect(inspectFallback) }
-    return `{ idx: ${util.inspect(this.idx, false, 2)} }`
   }
 
   override findCookie(
@@ -310,89 +290,3 @@ export class MemoryCookieStore extends Store {
     return promiseCallback.resolve(cookies)
   }
 }
-
-export function inspectFallback(val: unknown): string {
-  if (typeof val === 'string') {
-    return `'${val}'`
-  }
-
-  if (val && typeof val === 'object') {
-    const domains = Object.keys(val)
-    if (domains.length === 0) {
-      return '[Object: null prototype] {}'
-    }
-    let result = '[Object: null prototype] {\n'
-    Object.keys(val).forEach((domain, i) => {
-      if (inOperator(domain, val)) {
-        result += formatDomain(domain, val[domain])
-        if (i < domains.length - 1) {
-          result += ','
-        }
-        result += '\n'
-      }
-    })
-    result += '}'
-    return result
-  }
-
-  return String(val)
-}
-
-function formatDomain(domainName: string, domainValue: unknown) {
-  if (typeof domainValue === 'string') {
-    return `'${domainValue}'`
-  }
-
-  if (domainValue && typeof domainValue === 'object') {
-    const indent = '  '
-    let result = `${indent}'${domainName}': [Object: null prototype] {\n`
-    Object.keys(domainValue).forEach((path, i, paths) => {
-      if (inOperator(path, domainValue)) {
-        result += formatPath(path, domainValue[path])
-        if (i < paths.length - 1) {
-          result += ','
-        }
-        result += '\n'
-      }
-    })
-    result += `${indent}}`
-    return result
-  }
-
-  return String(domainValue)
-}
-
-function formatPath(pathName: string, pathValue: unknown) {
-  if (typeof pathValue === 'string') {
-    return `'${pathValue}'`
-  }
-
-  if (pathValue && typeof pathValue === 'object') {
-    const indent = '    '
-    let result = `${indent}'${pathName}': [Object: null prototype] {\n`
-    Object.keys(pathValue).forEach((cookieName, i, cookieNames) => {
-      if (inOperator(cookieName, pathValue)) {
-        const cookie = pathValue[cookieName]
-        if (
-          cookie != null &&
-          typeof cookie === 'object' &&
-          inOperator('inspect', cookie) &&
-          typeof cookie.inspect === 'function'
-        ) {
-          const inspectedValue: unknown = cookie.inspect()
-          if (typeof inspectedValue === 'string') {
-            result += `      ${cookieName}: ${inspectedValue}`
-            if (i < cookieNames.length - 1) {
-              result += ','
-            }
-            result += '\n'
-          }
-        }
-      }
-    })
-    result += `${indent}}`
-    return result
-  }
-
-  return String(pathValue)
-}