Merge pull request #920 from wheresrhys/rhys/is-subset-of

fix: remove deprecated is-subset-of

Author: wheresrhys

docs/docs/Usage/configuration.md

@@ -25,7 +25,7 @@ Sets a `Content-Length` header on each response, with the exception of responses
 
 `{Boolean}` default: `false`
 
-Match calls that only partially match a specified body json. Uses the [is-subset](https://www.npmjs.com/package/is-subset) library under the hood, which implements behaviour the same as jest's [.objectContaining()](https://jestjs.io/docs/en/expect#expectobjectcontainingobject) method.
+Match calls that only partially match a specified body json or FormData.
 
 ### allowRelativeUrls<sup>†</sup>
 

package-lock.json

@@ -24,7 +24,6 @@
 		"@types/glob-to-regexp": "^0.4.4",
 		"dequal": "^2.0.3",
 		"glob-to-regexp": "^0.4.1",
-		"is-subset-of": "^3.1.10",
 		"regexparam": "^3.0.0"
 	},
 	"repository": {

packages/fetch-mock/package.json

@@ -0,0 +1,190 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/** Copied from deprecated https://www.npmjs.com/package/is-subset-of **/
+import { Type } from './TypeDescriptor.js';
+
+const allowedTypes = new Set(['array', 'object', 'function', 'null']);
+
+const isSubsetOf = function (
+	subset: any[] | Record<string, any | undefined> | null,
+	superset: any[] | Record<string, any | undefined> | null,
+	visited: string[] = [],
+): boolean {
+	const subsetType = Type.of(subset);
+	const supersetType = Type.of(superset);
+
+	if (!allowedTypes.has(subsetType)) {
+		throw new Error(`Type '${subsetType}' is not supported.`);
+	}
+	if (!allowedTypes.has(supersetType)) {
+		throw new Error(`Type '${supersetType}' is not supported.`);
+	}
+
+	if (Type.isFunction(subset)) {
+		if (!Type.isFunction(superset)) {
+			throw new Error(
+				`Types '${subsetType}' and '${supersetType}' do not match.`,
+			);
+		}
+
+		return subset.toString() === superset.toString();
+	}
+
+	if (Type.isArray(subset)) {
+		if (!Type.isArray(superset)) {
+			throw new Error(
+				`Types '${subsetType}' and '${supersetType}' do not match.`,
+			);
+		}
+		if (subset.length > superset.length) {
+			return false;
+		}
+
+		for (const subsetItem of subset) {
+			const subsetItemType = Type.of(subsetItem);
+
+			let isItemInSuperset;
+
+			switch (subsetItemType) {
+				case 'array':
+				case 'object':
+				case 'function': {
+					if (visited.includes(subsetItem)) {
+						continue;
+					}
+
+					visited.push(subsetItem);
+
+					isItemInSuperset = superset.some((supersetItem: any): boolean => {
+						try {
+							return isSubsetOf(subsetItem, supersetItem, visited);
+						} catch {
+							return false;
+						}
+					});
+					break;
+				}
+				default: {
+					isItemInSuperset = superset.includes(subsetItem);
+				}
+			}
+
+			if (!isItemInSuperset) {
+				return false;
+			}
+		}
+
+		return true;
+	}
+
+	if (Type.isObject(subset)) {
+		if (!Type.isObject(superset) || Type.isArray(superset)) {
+			throw new Error(
+				`Types '${subsetType}' and '${supersetType}' do not match.`,
+			);
+		}
+		if (Object.keys(subset).length > Object.keys(superset).length) {
+			return false;
+		}
+
+		for (const [subsetKey, subsetValue] of Object.entries(subset)) {
+			const supersetValue = superset[subsetKey];
+
+			const subsetValueType = Type.of(subsetValue);
+
+			switch (subsetValueType) {
+				case 'array':
+				case 'object':
+				case 'function': {
+					if (visited.includes(subsetValue)) {
+						continue;
+					}
+
+					visited.push(subsetValue);
+
+					try {
+						const isInSuperset = isSubsetOf(
+							subsetValue,
+							supersetValue,
+							visited,
+						);
+
+						if (!isInSuperset) {
+							return false;
+						}
+					} catch {
+						return false;
+					}
+					break;
+				}
+				default: {
+					if (subsetValue !== supersetValue) {
+						return false;
+					}
+				}
+			}
+		}
+
+		return true;
+	}
+
+	if (Type.isNull(subset)) {
+		if (!Type.isNull(superset)) {
+			throw new Error(
+				`Types '${subsetType}' and '${supersetType}' do not match.`,
+			);
+		}
+
+		return true;
+	}
+
+	throw new Error('Invalid operation.');
+};
+
+isSubsetOf.structural = function (
+	subset: Record<string, any> | null,
+	superset: Record<string, any> | null,
+	visited: string[] = [],
+): boolean {
+	if (!Type.isObject(subset)) {
+		throw new Error(`Type '${Type.of(subset)}' is not supported.`);
+	}
+
+	if (!Type.isObject(superset)) {
+		throw new Error(`Type '${Type.of(superset)}' is not supported.`);
+	}
+
+	for (const [subsetKey, subsetValue] of Object.entries(subset)) {
+		if (superset[subsetKey] === undefined) {
+			return false;
+		}
+
+		const subsetValueType = Type.of(subsetValue);
+		const supersetValue = superset[subsetKey];
+
+		if (subsetValueType === 'object') {
+			if (visited.includes(subsetValue)) {
+				continue;
+			}
+
+			visited.push(subsetValue);
+
+			try {
+				const isInSuperset = isSubsetOf.structural(
+					subsetValue,
+					supersetValue,
+					visited,
+				);
+
+				if (!isInSuperset) {
+					return false;
+				}
+			} catch {
+				return false;
+			}
+		}
+	}
+
+	return true;
+};
+
+export { isSubsetOf };

packages/fetch-mock/src/IsSubsetOf.ts

@@ -2,7 +2,7 @@ import { RouteConfig } from './Route.js';
 import { CallLog } from './CallHistory.js';
 import glob from 'glob-to-regexp';
 import * as regexparam from 'regexparam';
-import { isSubsetOf } from 'is-subset-of';
+import { isSubsetOf } from './IsSubsetOf.js';
 import { dequal as isEqual } from 'dequal';
 import { normalizeHeaders, getPath, normalizeUrl } from './RequestUtils.js';