.circleci/config.yml

@@ -57,18 +57,22 @@ jobs:
     steps:
       - *workspace
       - run: npm run lint:ci
+      - run: npm run prettier:ci
 
   typelint:
     <<: *nodelts
     steps:
       - *workspace
       - run: npm run types:lint
+      - run: npm run types:check --noEmit=true
 
   test:
     <<: *nodelts
     steps:
       - *workspace
       - run: npm run test:ci
+      - store_test_results:
+          path: test-results
 
   nodefetch3:
     <<: *nodelts
@@ -89,6 +93,14 @@ jobs:
       - *workspace
       - run: npm run build
       - run: npm run test:jest
+  import-compat:
+    <<: *nodelts
+    steps:
+      - *workspace
+      - run: npm run compat:ts:cjs -w import-compat
+      - run: npm run compat:js:cjs -w import-compat
+      - run: npm run compat:ts:esm -w import-compat
+      - run: npm run compat:js:esm -w import-compat
   # chrome:
   #   <<: *browsers
   #   steps:
@@ -131,12 +143,10 @@ workflows:
           <<: *triggerable-by-tag
           requires:
             - checkout_code
-      # could be parallel with build, lint, and unit but it's a slow job
-      # And circlecifree tier only has 3 concurrent jobs, so overall faster
-      # to defer
       - typelint:
           <<: *triggerable-by-tag
-          <<: *run-after-first-jobs
+          requires:
+            - checkout_code
       - nodefetch3:
           <<: *triggerable-by-tag
           <<: *run-after-first-jobs
@@ -146,6 +156,10 @@ workflows:
       - jest:
           <<: *triggerable-by-tag
           <<: *run-after-first-jobs
+      - import-compat:
+          <<: *triggerable-by-tag
+          requires:
+            - build
       # - chrome:
       #     <<: *triggerable-by-tag
       #     <<: *run-after-first-jobs
@@ -158,6 +172,7 @@ workflows:
             # - chrome
             # - firefox
             - build
+            # - import-compat
             - typelint
             - commonjs
             - jest

.gitignore

@@ -1,4 +1,4 @@
-/node_modules/
+node_modules/
 
 # tooling artefacts
 /docs/.sass-cache/
@@ -13,3 +13,7 @@ coverage/
 # built files
 /docs/fetch-mock/dist/
 /packages/**/dist
+
+import-compat/*.js
+import-compat/*.mjs
+test-results

.husky/pre-commit

@@ -1 +1 @@
-npm run lint
+npx lint-staged

.prettierignore

@@ -0,0 +1 @@
+CHANGELOG.md

.release-please-manifest.json

@@ -1,4 +1,4 @@
 {
-  "packages/core": "0.3.1",
-  "packages/fetch-mock": "10.1.1"
+  "packages/core": "0.4.8",
+  "packages/fetch-mock": "11.0.0"
 }

docs/blog/2024-07-21-introducing-core.md

@@ -53,6 +53,14 @@ fetchMock.mock('http://my.site', 200);
 
 which keeps fetch-mock's methods much further away from any other library's workings.
 
+## .getAny(), .postAny(), .putAny(), .deleteAny(), .headAny(), .patchAny(), .getAnyOnce(), .postAnyOnce(), .putAnyOnce(), .deleteAnyOnce(), .headAnyOnce(), .patchAnyOnce()
+
+While `.getOnce()` etc feel very useful, the `any` and `anyOnce` variants added a lot of repetition to the code and types, and don't actually add much value.
+
+`.___AnyOnce(response, options)`
+
+Creates a route that responds to any single request using a particular http method.
+
 ### Gone, but back soon
 
 The following features will return in other libraries that wrap @fetch-mock/core for different environments.

docs/blog/2024-07-24-esm-and-commonjs.md

@@ -0,0 +1,26 @@
+---
+title: Publishing packages as ESM and commonjs
+slug: esm-and-commonjs
+authors:
+  - name: Rhys Evans
+    title: fetch-mock maintainer
+    url: https://www.wheresrhys.co.uk
+hide_table_of_contents: false
+---
+
+Publishing a package that is compatible with all the following is not straightforward
+
+1. A commonjs javascript project
+2. A ESM javascript project
+3. A commonjs typescript project
+4. A ESM typescript project
+
+I previously thought I'd cracked it by adding `"type": "module"` to the package.json but including a `{"type": "commonjs"}` package.json to the subdirectory that contained my commonjs built files.
+
+However [this issue](https://github.com/wheresrhys/fetch-mock/issues/726) indicated that use case 3 was not supported. [This article](https://www.sensedeep.com/blog/posts/2021/how-to-create-single-source-npm-module.html) suggested that the best solution was to build a .mjs file for ESM, a .cjs file for CJS, and leave the top level package.json without a `"type": "module"` declaration.
+
+I'm not a big fan of this as it makes it harder to fork the library or test a branch because every way of requiring it entails a build step, which is typically not carried out when requireing directly from a branch.
+
+So after mulling things over I came up with a simple solution: remove the `"type": "module"` declaration from the top level package.json and instead create a `{"type": "module"}` package.json in my srcdirectory.
+
+I thought I'd share as it's not obvious this would work - I did a fair bit of manual testing to prove it - but it's an elegant and low-build approach I've not seen publicised elsewhere.

docs/docs/@fetch-mock/core/CallHistory.md

@@ -10,14 +10,15 @@ sidebar_position: 4
 
 Calls are recorded, and returned, in a standard format with the following properties:
 
-- `[string|Request,Object]` - the original arguments passed in to `fetch`
-- `{string} url` - The url being fetched
-- `{NormalizedRequestOptions} options` - The options passed in to the fetch (may be derived from a `Request` if one was used)
-- `{Request} [request]` - The `Request` passed to fetch, if one was used
-- `{Route} [route]` - The route used to handle the request
-- `{Response} [response]` - The `Response` returned to the user
-- `{Object.<string,string>}` - Any express parameters extracted from the `url`
-- `{Promise<any>[]} pendingPromises` - An internal structure used by the `.flush()` method documented below
+- **arguments** `[string|Request,Object]` - the original arguments passed in to `fetch`
+- **url** `{string}` - The url being fetched
+- **options** `{NormalizedRequestOptions}` - The options passed in to the fetch (may be derived from a `Request` if one was used)
+- **request** `{Request}` - The `Request` passed to fetch, if one was used
+- **route** `{Route}` - The route used to handle the request
+- **response** `{Response}` - The `Response` returned to the user
+- **expressParams** `{Object.<string,string>}` - Any express parameters extracted from the `url`
+- **queryParams** `{URLSearchParams}` - Any query parameters extracted from the `url`
+- **pendingPromises** `{Promise<any>[]} ` - An internal structure used by the `.flush()` method documented below
 
 ## Filtering
 

docs/docs/@fetch-mock/core/index.md

@@ -12,3 +12,21 @@ This library implements three main features
 3. Some low level APIs for accessing the call history of `fetchHandler` (these are not intended for direct use by the developer, but expose enough information for other libraries, such as `@fetch-mock/jest`, to provide more user friendly APIs built on top of this low level functionality).
 
 `@fetch-mock/core` is not intended for direct use in tests. It **DOES NOT** actually replace your `fetch` implementation with `fetchHandler`; this is left to wrapper libraries such as `@fetch-mock/jest`. This is because different testing frameworks have different opinions about this behaviour, and this core library deliberately avoids making decisions likely to clash with other tools in your testing toolchain, so that the `fetchHandler` implementation is more portable.
+
+```js
+import fetchMock from '@fetch-mock/core';
+describe('myModule', () => {
+	beforeEach(() => fetchMock.mockGlobal())
+
+	it('gets user data from the api endpoint', async () => {
+		fetchMock.route({
+			express: '/api/users/:user'
+			expressParams: {user: 'kenneth'}
+		}, {userData: {}}, 'userDataFetch')
+		await myModule.initialiseUserPage({user: 'kenneth'})
+		expect(fetchMock.called('userDataFetch'))
+
+	})
+})
+
+```

docs/docs/@fetch-mock/core/mocking-and-spying.md

@@ -0,0 +1,29 @@
+---
+sidebar_position: 3
+---
+
+# Mocking and spying
+
+These methods allow mocking or spying on the `fetch` implementation used by your application.
+
+Note that these methods are only implemented in `@fetch-mock/core` and are not avilable when using `@fetch-mock/jest`, `@fetch-mock/vitest` etc.... Those libraries provide ways to mock `fetch` that are more idiomatic to their own ecosystem.
+
+## When using global fetch in your application
+
+### mockGlobal()
+
+Replaces `globalThis.fetch` with `fm.fetchHandler`
+
+### unmockGlobal()
+
+Restores `globalThis.fetch` to its original state
+
+### spy(matcher, name)
+
+Falls back to the `fetch` implementation set in `fetchMock.config.fetch` for a specific route (which can be named).
+
+When no arguments are provided it will fallback to the native fetch implementation for all requests, similar to `.catch()`
+
+### spyGlobal()
+
+Equivalent to calling `.mockGlobal()` followed by `.spy()`

docs/docs/@fetch-mock/core/more-routing-methods.md

@@ -5,7 +5,7 @@ sidebar_label: More routing methods
 
 # More routing methods
 
-These methods allow defining routes for common use cases while avoiding writing hard to read configuration objects. They all return the fetchMock instance, and are therefor chainable. Unless noted otherwise, each of the methods below have the same signature as `.route()`. 
+These methods allow defining routes for common use cases while avoiding writing hard to read configuration objects. They all return the fetchMock instance, and are therefor chainable. Unless noted otherwise, each of the methods below have the same signature as `.route()`.
 
 ## .catch()
 
@@ -61,18 +61,6 @@ fetchMock.purge = function (matcher, response, options) {
 
 Creates a route that only responds to a single request using a particular http method
 
-## .getAny(), .postAny(), .putAny(), .deleteAny(), .headAny(), .patchAny()
-
-`.___Any(response, options)`
-
-Creates a route that responds to any requests using a particular http method.
-
-## .getAnyOnce(), .postAnyOnce(), .putAnyOnce(), .deleteAnyOnce(), .headAnyOnce(), .patchAnyOnce()
-
-`.___AnyOnce(response, options)`
-
-Creates a route that responds to any single request using a particular http method.
-
 ## .addMatcher(options)
 
 Allows adding your own, reusable custom matchers to fetch-mock, for example a matcher for interacting with GraphQL queries, or an `isAuthorized` matcher that encapsulates the exact authorization conditions for the API you are mocking, and only requires a `true` or `false` to be input

docs/docs/@fetch-mock/core/resetting.md

@@ -26,6 +26,10 @@ A boolean indicating whether or not to remove the fallback route (added using `.
 
 Clears all data recorded for `fetch`'s calls.
 
+## unmockGlobal()
+
+Restores global `fetch` to its original state if `.mockGlobal()` or `.spyGlobal()` have been used .
+
 ## .createInstance()
 
 Can be used to create a standalone instance of fetch mock that is completely independent of other instances.

docs/docs/@fetch-mock/core/route/matcher.md

@@ -71,17 +71,31 @@ Match a url that satisfies an [express style path](https://www.npmjs.com/package
 
 When the `express:` keyword is used in a string matcher, it can be combined with the `{params: ...}` matcher to match only requests whose express parameters evaluate to certain values. e.g.
 
-```
+```js
 {
-	express: "/:section/user/:user",
+	url: "express:/:section/user/:user",
 	params: {"section": "feed", "user": "geoff"}
 }
 ```
 
-The values of express parameters are made available in the `expressParams` property when 
+The values of express parameters are made available in the `expressParams` property when
+
 - [Inspecting call history](/fetch-mock/docs/@fetch-mock/core/CallHistory#calllog-schema)
 - [Using a function to construct a response](/fetch-mock/docs/@fetch-mock/core/route/response#function)
 
+### Multiple url matchers
+
+All of the above (with the exception of the full url matcher) can be combined in an object in order to match multiple patterns at once e.g.
+
+```js
+{
+	url: {
+		begin: 'https',
+		path: '/could/be/any/host'
+	}
+}
+```
+
 ## Other matching criteria
 
 ### method
@@ -96,6 +110,12 @@ Match only requests using this http method. Not case-sensitive, e.g. `{method: "
 
 Match only requests that have these headers set, e.g. `{headers: {"Accepts": "text/html"}}`
 
+#### missingHeaders
+
+`{String[]}`
+
+Matches any requests where **all** of a list of header names are missing on a request e.g. `{missingHeaders: ["Authorization"]}`.
+
 ### query
 
 `{Object}`

docs/docs/fetch-mock/Usage/versions.md

@@ -4,13 +4,15 @@ sidebar_position: 5
 
 # Versions
 
-### Version 10
+### Version 10/11
 
-This has 2 major differences from previous versions
+These have 2 major differences from previous versions
 
 1. It is written using ES modules
 2. It uses native fetch in node.js
 
+Version 11 is identical to version 10, with the exception that it changes the commonjs to use `exports.default = fetchMock` instead of `exports=fetchMock`.
+
 If you experience any compatibility issues upgrading from version 9, please either
 
 - try the approaches iom the troubleshooting section of these docs

import-compat/package.json

@@ -0,0 +1,10 @@
+{
+  "name": "fetch-mock-compat-tests",
+  "version": "1.0.0",
+  "scripts": {
+    "compat:ts:esm": "tsc ts-esm.ts --target esnext --moduleResolution nodenext --module nodenext && node ts-esm.js",
+    "compat:ts:cjs": "tsc ts-cjs.ts  --target esnext --moduleResolution nodenext --module nodenext && node ts-cjs.js",
+    "compat:js:esm": "cp ts-esm.ts js-esm.mjs && node js-esm.mjs",
+    "compat:js:cjs": "cp ts-cjs.ts js-cjs.js && node js-cjs.js"
+  }
+}

import-compat/ts-cjs.ts

@@ -0,0 +1,7 @@
+const {default: fetchMockCore, FetchMock} = require("@fetch-mock/core");
+fetchMockCore.route("http://example.com", 200);
+
+new FetchMock({})
+
+const fetchMock = require("fetch-mock").default;
+fetchMock.mock("http://example.com", 200);

import-compat/ts-esm.ts

@@ -0,0 +1,7 @@
+import fetchMockCore, {FetchMock} from "@fetch-mock/core";
+fetchMockCore.route("http://example.com", 200);
+
+new FetchMock({})
+
+import fetchMock from "fetch-mock";
+fetchMock.mock("http://example.com", 200);

jsconfig.json

@@ -5,22 +5,32 @@
             "dom",
             "dom.iterable"
         ],
+        "moduleResolution": "nodenext",
+        "module": "NodeNext",
         "allowJs": true,
         "checkJs": true,
         "strict": true,
         "noImplicitAny": true,
         "noImplicitThis": true,
         "strictNullChecks": false,
         "strictFunctionTypes": true,
-        "types": [        ],
-        "noEmit": true,
+        "types": [
+        ],
         "downlevelIteration": true,
-        "forceConsistentCasingInFileNames": true
+        "forceConsistentCasingInFileNames": true,
+        "declaration": true,
+        "emitDeclarationOnly": true,
+        "outDir": "packages/core/types",
+        "skipLibCheck": true,
+        "noEmit": false,
+        "target": "es2021",
+        "removeComments": true
     },
     "include": [
-        "packages/core/src/*.js",
+        "./packages/core/src/*.js"
     ],
     "exclude": [
-        "node_modules"
+        "node_modules",
+        "packages/**/src/__tests__"
     ]
-}
+}