nock 15.0.0 → 15.0.1

package/{lib → dist/lib}/intercept.js

@@ -1,32 +1,16 @@
-'use strict'
-
-const common = require('./common')
-const { intercept: debug } = require('./debug')
-const builtinMock = require('./interceptors/builtin')
-let undiciMock // Lazy-loaded, optional peer dependency
-
-let allInterceptors = {}
-let allowNetConnect
-let isActive = false
-
-/**
- * Enabled real request.
- * @public
- * @param {String|RegExp} matcher=RegExp.new('.*') Expression to match
- * @example
- * // Enables all real requests
- * nock.enableNetConnect();
- * @example
- * // Enables real requests for url that matches google
- * nock.enableNetConnect('google');
- * @example
- * // Enables real requests for url that matches google and amazon
- * nock.enableNetConnect(/(google|amazon)/);
- * @example
- * // Enables real requests for url that includes google
- * nock.enableNetConnect(host => host.includes('google'));
- */
-function enableNetConnect(matcher) {
+                                                   
+                                       
+import * as common from './common.js'
+import { intercept as debug } from './debug.js'
+import * as builtinMock from './interceptors/builtin.js'
+
+let allInterceptors                      = {}
+let allowNetConnect                                                         
+let _isActive = false
+
+function enableNetConnect(
+  matcher                                                ,
+) {
   if (typeof matcher === 'string') {
     allowNetConnect = new RegExp(matcher)
   } else if (matcher instanceof RegExp) {
@@ -38,18 +22,12 @@ function enableNetConnect(matcher) {
   }
 }
 
-function isEnabledForNetConnect(url) {
-  const enabled = allowNetConnect && allowNetConnect.test(url)
+function isEnabledForNetConnect(url        ) {
+  const enabled = !!(allowNetConnect && allowNetConnect.test(url))
   debug('Net connect', enabled ? '' : 'not', 'enabled for', url)
   return enabled
 }
 
-/**
- * Disable all real requests.
- * @public
- * @example
- * nock.disableNetConnect();
- */
 function disableNetConnect() {
   allowNetConnect = undefined
 }
@@ -62,7 +40,13 @@ function isOff() {
   return process.env.NOCK_OFF === 'true'
 }
 
-function addInterceptor(key, interceptor, scope, scopeOptions, host) {
+function addInterceptor(
+  key        ,
+  interceptor             ,
+  scope       ,
+  scopeOptions                     ,
+  host        ,
+) {
   if (!(key in allInterceptors)) {
     allInterceptors[key] = { key, interceptors: [] }
   }
@@ -80,39 +64,35 @@ function addInterceptor(key, interceptor, scope, scopeOptions, host) {
   allInterceptors[key].interceptors.push(interceptor)
 }
 
-function remove(interceptor) {
-  if (interceptor.__nock_scope.shouldPersist() || --interceptor.counter > 0) {
+function remove(interceptor             ) {
+  if (interceptor.__nock_scope?.shouldPersist() || --interceptor.counter > 0) {
     return
   }
 
-  const { basePath } = interceptor
+  const basePath = interceptor.basePath          
   const interceptors =
     (allInterceptors[basePath] && allInterceptors[basePath].interceptors) || []
 
   // TODO: There is a clearer way to write that we want to delete the first
   // matching instance. I'm also not sure why we couldn't delete _all_
   // matching instances.
-  interceptors.some(function (thisInterceptor, i) {
+  interceptors.some(function (thisInterceptor             , i        ) {
     return thisInterceptor === interceptor ? interceptors.splice(i, 1) : false
   })
 }
 
 function removeAll() {
   Object.keys(allInterceptors).forEach(function (key) {
-    allInterceptors[key].interceptors.forEach(function (interceptor) {
+    allInterceptors[key].interceptors.forEach(function (
+      interceptor             ,
+    ) {
       interceptor.scope.keyedInterceptors = {}
     })
   })
   allInterceptors = {}
 }
 
-/**
- * Return all the Interceptors whose Scopes match against the base path of the provided options.
- *
- * @param {URL} url
- * @returns {Interceptor[]}
- */
-function interceptorsFor(url) {
+function interceptorsFor(url     ) {
   debug('interceptors for %j', url.host)
 
   const port = url.port || (url.protocol === 'https:' ? 443 : 80)
@@ -135,7 +115,7 @@ function interceptorsFor(url) {
 
         // Keep the filtered scope (its key) to signal the rest of the module
         // that this wasn't an exact but filtered match.
-        interceptors.forEach(ic => {
+        interceptors.forEach((ic             ) => {
           ic.__nock_filteredScope = ic.__nock_scopeKey
         })
         return interceptors
@@ -167,21 +147,30 @@ function interceptorsFor(url) {
   return undefined
 }
 
-function removeInterceptor(options) {
-  // Lazily import to avoid circular imports.
-  const Interceptor = require('./interceptor')
+import { Interceptor as InterceptorClass } from './interceptor.js'
 
+function removeInterceptor(
+  options 
+                 
+                                                                       ,
+) {
   let baseUrl, key, method, proto
-  if (options instanceof Interceptor) {
-    baseUrl = options.basePath
-    key = options._key
+  if (options instanceof InterceptorClass) {
+    baseUrl = (options               ).basePath          
+    key = (options               )._key
   } else {
-    proto = options.proto ? options.proto : 'http'
-
-    common.normalizeRequestOptions(options)
-    baseUrl = `${proto}://${options.host}`
-    method = (options.method && options.method.toUpperCase()) || 'GET'
-    key = `${method} ${baseUrl}${options.path || '/'}`
+    const opts = options     
+                    
+                   
+                     
+                   
+     
+    proto = opts.proto ? opts.proto : 'http'
+
+    common.normalizeRequestOptions(opts)
+    baseUrl = `${proto}://${opts.host}`
+    method = (opts.method && opts.method.toUpperCase()) || 'GET'
+    key = `${method} ${baseUrl}${opts.path || '/'}`
   }
 
   if (
@@ -191,12 +180,16 @@ function removeInterceptor(options) {
     for (let i = 0; i < allInterceptors[baseUrl].interceptors.length; i++) {
       const interceptor = allInterceptors[baseUrl].interceptors[i]
       if (
-        options instanceof Interceptor
+        options instanceof InterceptorClass
           ? interceptor === options
           : interceptor._key === key
       ) {
         allInterceptors[baseUrl].interceptors.splice(i, 1)
         interceptor.scope.remove(key, interceptor)
+        interceptor.scope.interceptors.splice(
+          interceptor.scope.interceptors.indexOf(interceptor),
+          1,
+        )
         break
       }
     }
@@ -209,10 +202,14 @@ function removeInterceptor(options) {
 
 function interceptorScopes() {
   const nestedInterceptors = Object.values(allInterceptors).map(
-    i => i.interceptors,
+    (i     ) => i.interceptors,
+  )
+  const scopes = new Set(
+    ([]                 )
+      .concat(...nestedInterceptors)
+      .map((i             ) => i.scope),
   )
-  const scopes = new Set([].concat(...nestedInterceptors).map(i => i.scope))
-  return [...scopes]
+  return [...scopes]           
 }
 
 function isDone() {
@@ -220,61 +217,51 @@ function isDone() {
 }
 
 function pendingMocks() {
-  return [].concat(...interceptorScopes().map(scope => scope.pendingMocks()))
+  return ([]            ).concat(
+    ...interceptorScopes().map(scope => scope.pendingMocks()),
+  )
 }
 
 function activeMocks() {
-  return [].concat(...interceptorScopes().map(scope => scope.activeMocks()))
+  return ([]            ).concat(
+    ...interceptorScopes().map(scope => scope.activeMocks()),
+  )
 }
 
 function activate() {
-  if (!isActive) {
+  if (!_isActive) {
     builtinMock.activate()
-
-    // Lazy load undiciMock only when activate is called
-    if (!undiciMock) {
-      try {
-        undiciMock = require('./interceptors/undici')
-      } catch (err) {
-        if (err.code !== 'MODULE_NOT_FOUND') {
-          throw err
-        }
-        debug(
-          'Undici mocking is disabled because the undici module is not installed',
-        )
-      }
-    }
-
-    undiciMock?.activate()
-    isActive = true
+    _isActive = true
   } else {
     throw new Error('Nock already active')
   }
 }
 
 function deactivate() {
-  if (isActive) {
+  if (_isActive) {
     builtinMock.deactivate()
-    undiciMock?.deactivate()
-    isActive = false
+    _isActive = false
   }
 }
 
-module.exports = {
+const isActiveFn = () => _isActive
+const abortPendingRequests = common.removeAllTimers
+
+export {
   addInterceptor,
   remove,
   removeAll,
   removeInterceptor,
   isOn,
   activate,
-  isActive: () => isActive,
+  isActiveFn as isActive,
   isDone,
   pendingMocks,
   activeMocks,
   enableNetConnect,
   disableNetConnect,
-  restoreOverriddenClientRequest: deactivate,
-  abortPendingRequests: common.removeAllTimers,
+  deactivate as restoreOverriddenClientRequest,
+  abortPendingRequests,
   interceptorsFor,
   isEnabledForNetConnect,
 }

package/dist/lib/interceptor.d.ts

@@ -0,0 +1,44 @@
+import type { ReadStream } from 'node:fs';
+import type { Scope, Options } from './scope.ts';
+export type DataMatcher = boolean | number | string | null | undefined | RegExp | DataMatcherArray | DataMatcherMap;
+export type DataMatcherArray = ReadonlyArray<DataMatcher>;
+export type DataMatcherMap = {
+    [key: string]: DataMatcher;
+};
+export type RequestBodyMatcher = string | Buffer | RegExp | DataMatcherArray | DataMatcherMap | ((body: any) => boolean);
+export type RequestHeaderMatcher = string | RegExp | ((fieldValue: string | null) => boolean);
+export type Body = string | Record<string, any>;
+export type ReplyBody = Body | Buffer | ReadStream;
+export type ReplyHeaderFunction = (req: Request, body?: string | Buffer) => string | string[] | Promise<string | string[]>;
+export type ReplyHeaderValue = string | string[] | ReplyHeaderFunction;
+export type ReplyHeaders = Record<string, ReplyHeaderValue> | Map<string, ReplyHeaderValue> | ReplyHeaderValue[];
+export type StatusCode = number;
+export type ReplyFnResult = readonly [StatusCode] | readonly [StatusCode, ReplyBody] | readonly [StatusCode, ReplyBody, ReplyHeaders];
+import { URLSearchParams } from 'node:url';
+declare class Interceptor {
+    constructor(scope: Scope, uri: string | RegExp | ((path: string) => boolean), method: string, requestBody?: RequestBodyMatcher, interceptorOptions?: Options);
+    optionally(flag?: boolean): this;
+    passthrough(): Scope;
+    replyWithError(errorMessage: string | Error | Record<string, any>): Scope;
+    reply(statusCode: any, body?: any, rawHeaders?: ReplyHeaders): Scope;
+    replyWithFile(statusCode: number, filePath: string, headers?: ReplyHeaders): Scope;
+    reqheaderMatches(expected: RequestHeaderMatcher, actual: string | null, key: string): boolean;
+    match(request: Request, body: string): string[];
+    matchOrigin(request: Request): boolean;
+    matchHostName(hostname: string): boolean;
+    matchQuery(options: Record<string, any>): any;
+    filteringPath(...args: any[]): this;
+    markConsumed(): void;
+    matchHeader(name: string, value: RequestHeaderMatcher): this;
+    basicAuth({ user, pass }: {
+        user: string;
+        pass?: string;
+    }): this;
+    query(queries: boolean | string | URLSearchParams | Record<string, any> | ((queryObject: Record<string, any>) => boolean)): this;
+    times(newCounter: number): this;
+    once(): this;
+    twice(): this;
+    thrice(): this;
+    delay(ms: number): this;
+}
+export { Interceptor };