mock-config-server 5.0.0-beta.2 → 5.0.0-beta.4

package/dist/src/core/database/createDatabaseRoutes/helpers/createShallowDatabaseRoutes/createShallowDatabaseRoutes.mjs

@@ -0,0 +1,64 @@
+import { filter } from "../filter/filter.mjs";
+import { pagination } from "../pagination/pagination.mjs";
+import { search } from "../search/search.mjs";
+import { sort } from "../sort/sort.mjs";
+//#region src/core/database/createDatabaseRoutes/helpers/createShallowDatabaseRoutes/createShallowDatabaseRoutes.ts
+const createShallowDatabaseRoutes = (router, database, storage) => {
+	Object.keys(database).forEach((key) => {
+		const path = `/${key}`;
+		router.route(path).get((request, response) => {
+			let data = storage.read(key);
+			if (!Array.isArray(data) || !request.query) {
+				response.set("Cache-control", "no-cache");
+				return response.json(data);
+			}
+			data = data.filter((element) => typeof element === "object" && element !== null);
+			const { _page, _limit, _begin, _end, _sort, _order, _q, ...filters } = request.query;
+			if (Object.keys(filters).length) data = filter(data, filters);
+			if (_q) data = search(data, request.query._q);
+			if (_sort) data = sort(data, request.query);
+			if (_begin || _end) {
+				data = data.slice(request.query._begin ?? 0, request.query._end);
+				response.set("X-Total-Count", data.length);
+			}
+			if (_page) {
+				data = pagination(data, request.query);
+				if (data._link) {
+					const links = {};
+					const fullUrl = `${request.protocol}://${request.get("host")}${request.originalUrl}`;
+					if (data._link.first) links.first = fullUrl.replace(`page=${data._link.current}`, `page=${data._link.first}`);
+					if (data._link.prev) links.prev = fullUrl.replace(`page=${data._link.current}`, `page=${data._link.prev}`);
+					if (data._link.next) links.next = fullUrl.replace(`page=${data._link.current}`, `page=${data._link.next}`);
+					if (data._link.last) links.last = fullUrl.replace(`page=${data._link.current}`, `page=${data._link.last}`);
+					data._link = {
+						...data._link,
+						...links
+					};
+					response.links(links);
+				}
+			}
+			response.set("Cache-control", "no-cache");
+			response.json(data);
+		});
+		router.route(path).post((request, response) => {
+			storage.write(key, request.body);
+			response.set("Location", request.url);
+			response.status(201).json(request.body);
+		});
+		router.route(path).put((request, response) => {
+			storage.write(key, request.body);
+			response.json(request.body);
+		});
+		router.route(path).patch((request, response) => {
+			const updatedResource = {
+				...storage.read(key),
+				...request.body
+			};
+			storage.write(key, updatedResource);
+			response.json(updatedResource);
+		});
+	});
+	return router;
+};
+//#endregion
+export { createShallowDatabaseRoutes };

package/dist/src/core/database/createDatabaseRoutes/helpers/filter/filter.mjs

@@ -0,0 +1,47 @@
+import { flatten } from "flat";
+//#region src/core/database/createDatabaseRoutes/helpers/filter/filter.ts
+const OPERATORS = {
+	eq: (a, b) => `${a}` === `${b}`,
+	neq: (a, b) => `${a}` !== `${b}`,
+	gt: (a, b) => +a > +b,
+	gte: (a, b) => +a >= +b,
+	lt: (a, b) => +a < +b,
+	lte: (a, b) => +a <= +b,
+	cn: (a, b) => a.includes(b),
+	ncn: (a, b) => !a.includes(b),
+	sw: (a, b) => a.startsWith(b),
+	nsw: (a, b) => !a.startsWith(b),
+	ew: (a, b) => a.endsWith(b),
+	new: (a, b) => !a.endsWith(b),
+	some: (a, b) => a.some((element) => `${element}` === `${b}`)
+};
+const OPERATOR_REGEXP = new RegExp(`^(.+)_(${Object.keys(OPERATORS).join("|")})$`);
+const getEntities = (object, key) => {
+	const parts = key.match(OPERATOR_REGEXP);
+	if (!parts) return {
+		operator: "eq",
+		element: object[key]
+	};
+	const [, element, operator] = parts;
+	if (operator === "some") return {
+		operator,
+		element: Object.entries(object).filter(([objectKey]) => new RegExp(`^${element}.\\d$`).test(objectKey)).map(([, value]) => value)
+	};
+	return {
+		element: object[element],
+		operator
+	};
+};
+const filter = (array, filters) => array.filter((arrayElement) => {
+	const flattenedArrayElement = flatten(arrayElement);
+	return Object.entries(filters).every(([key, filter]) => {
+		if (Array.isArray(filter)) {
+			const { element, operator } = getEntities(flattenedArrayElement, key);
+			return filter.some((value) => OPERATORS[operator](element, value));
+		}
+		const { element, operator } = getEntities(flattenedArrayElement, key);
+		return OPERATORS[operator](element, filter);
+	});
+});
+//#endregion
+export { filter };

package/dist/src/core/database/createDatabaseRoutes/helpers/index.mjs

@@ -0,0 +1,8 @@
+import "./array/createNewId/createNewId.mjs";
+import "./array/findIndexById/findIndexById.mjs";
+import "./array/isIndex/isIndex.mjs";
+import "./createNestedDatabaseRoutes/createNestedDatabaseRoutes.mjs";
+import "./createRewrittenDatabaseRoutes/createRewrittenDatabaseRoutes.mjs";
+import "./createShallowDatabaseRoutes/createShallowDatabaseRoutes.mjs";
+import "./splitDatabaseByNesting/splitDatabaseByNesting.mjs";
+export {};

package/dist/src/core/database/createDatabaseRoutes/helpers/pagination/pagination.mjs

@@ -0,0 +1,30 @@
+//#region src/core/database/createDatabaseRoutes/helpers/pagination/pagination.ts
+const DEFAULT_LIMIT = 10;
+const pagination = (array, queries) => {
+	const { _page } = queries;
+	if (!_page || +_page <= 0) return array;
+	const page = +_page;
+	const limit = queries._limit && +queries._limit > 0 ? +queries._limit : DEFAULT_LIMIT;
+	const pages = Math.ceil(array.length / limit);
+	if (page > pages) return array;
+	const start = page * limit - limit;
+	const end = page * limit;
+	const results = array.slice(start, end);
+	const next = page + 1 <= pages ? page + 1 : null;
+	const prev = page - 1 !== 0 ? page - 1 : null;
+	const last = pages > 0 ? pages : null;
+	return {
+		_link: {
+			count: array.length,
+			pages,
+			first: 1,
+			current: page,
+			next,
+			prev,
+			last
+		},
+		results
+	};
+};
+//#endregion
+export { pagination };

package/dist/src/core/database/createDatabaseRoutes/helpers/search/search.mjs

@@ -0,0 +1,14 @@
+//#region src/core/database/createDatabaseRoutes/helpers/search/search.ts
+const searchInNestedObjects = (obj, searchText) => {
+	for (const key in obj) if (typeof obj[key] === "object" && obj[key] !== null) {
+		if (searchInNestedObjects(obj[key], searchText)) return true;
+	} else if (String(obj[key]).includes(searchText)) return true;
+	return false;
+};
+const search = (array, searchText) => array.filter((element) => {
+	if (typeof searchText === "string") return searchInNestedObjects(element, searchText);
+	if (Array.isArray(searchText)) return searchText.some((text) => searchInNestedObjects(element, text));
+	throw new Error("search technical error");
+});
+//#endregion
+export { search };

package/dist/src/core/database/createDatabaseRoutes/helpers/sort/sort.mjs

@@ -0,0 +1,30 @@
+import { flatten } from "flat";
+//#region src/core/database/createDatabaseRoutes/helpers/sort/sort.ts
+const DEFAULT_ORDER = "asc";
+const getOrder = (order) => {
+	if (order === "asc" || order === "desc") return order;
+	return DEFAULT_ORDER;
+};
+const sortArray = (array, key, order) => array.sort((a, b) => {
+	const flattenedA = flatten(a);
+	const flattenedB = flatten(b);
+	if (!flattenedA[key] || !flattenedB[key]) return 0;
+	if (typeof flattenedA[key] === "string" && typeof flattenedB[key] === "string") return order === "asc" ? flattenedA[key].localeCompare(flattenedB[key]) : flattenedB[key].localeCompare(flattenedA[key]);
+	return order === "asc" ? Number(flattenedA[key]) - Number(flattenedB[key]) : Number(flattenedB[key]) - Number(flattenedA[key]);
+});
+const sort = (array, queries) => {
+	const { _sort, _order = DEFAULT_ORDER } = queries;
+	if (!_sort) return array;
+	const result = [...array];
+	if (Array.isArray(_sort)) {
+		const orders = Array.isArray(_order) ? _order : [_order];
+		_sort.forEach((key, index) => {
+			sortArray(result, key, getOrder(orders[index]));
+		});
+		return result;
+	}
+	sortArray(result, _sort, getOrder(Array.isArray(_order) ? _order[0] : _order));
+	return result;
+};
+//#endregion
+export { sort };

package/dist/src/core/database/createDatabaseRoutes/helpers/splitDatabaseByNesting/splitDatabaseByNesting.mjs

@@ -0,0 +1,25 @@
+import { isPlainObject } from "../../../../../utils/helpers/isPlainObject/isPlainObject.mjs";
+import "../../../../../utils/helpers/index.mjs";
+//#region src/core/database/createDatabaseRoutes/helpers/splitDatabaseByNesting/splitDatabaseByNesting.ts
+const isAllArrayElementsHaveValidTypeId = (array) => array.every((element) => isPlainObject(element) && (typeof element.id === "number" || typeof element.id === "string"));
+const isAllArrayElementsHaveUniqueId = (array) => {
+	const uniqueIdsCount = new Set(array.map(({ id }) => id)).size;
+	return array.length === uniqueIdsCount;
+};
+const splitDatabaseByNesting = (data) => {
+	const shallowDatabase = {};
+	const nestedDatabase = {};
+	Object.entries(data).forEach(([databaseEntityKey, databaseEntityValue]) => {
+		if (Array.isArray(databaseEntityValue) && isAllArrayElementsHaveValidTypeId(databaseEntityValue) && isAllArrayElementsHaveUniqueId(databaseEntityValue)) {
+			nestedDatabase[databaseEntityKey] = databaseEntityValue;
+			return;
+		}
+		shallowDatabase[databaseEntityKey] = databaseEntityValue;
+	});
+	return {
+		shallowDatabase,
+		nestedDatabase
+	};
+};
+//#endregion
+export { splitDatabaseByNesting };

package/dist/src/core/database/createDatabaseRoutes/storages/File/FileStorage.mjs

@@ -0,0 +1,49 @@
+import { APP_PATH } from "../../../../../utils/constants/appPath.mjs";
+import "../../../../../utils/constants/index.mjs";
+import { isIndex } from "../../helpers/array/isIndex/isIndex.mjs";
+import "../../helpers/index.mjs";
+import { FileWriter } from "./FileWriter.mjs";
+import fs from "node:fs";
+import path from "node:path";
+//#region src/core/database/createDatabaseRoutes/storages/File/FileStorage.ts
+var FileStorage = class {
+	fileWriter;
+	data;
+	constructor(fileName) {
+		const filePath = path.resolve(APP_PATH, fileName);
+		this.fileWriter = new FileWriter(filePath);
+		this.data = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+	}
+	read(key) {
+		if (!key) return this.data;
+		const keys = Array.isArray(key) ? key : [key];
+		let readable = this.data;
+		for (const currentKey of keys) readable = readable[currentKey];
+		return readable;
+	}
+	write(key, value) {
+		const keys = Array.isArray(key) ? key : [key];
+		let writable = this.data;
+		let index = 0;
+		while (index < keys.length - 1) {
+			writable = writable[keys[index]];
+			index += 1;
+		}
+		writable[keys[index]] = value;
+		this.fileWriter.write(JSON.stringify(this.data));
+	}
+	delete(key) {
+		const keys = Array.isArray(key) ? key : [key];
+		let deletable = this.data;
+		let index = 0;
+		while (index < keys.length - 1) {
+			deletable = deletable[keys[index]];
+			index += 1;
+		}
+		if (Array.isArray(deletable) && isIndex(keys[index])) deletable.splice(keys[index], 1);
+		else delete deletable[keys[index]];
+		this.fileWriter.write(JSON.stringify(this.data));
+	}
+};
+//#endregion
+export { FileStorage };

package/dist/src/core/database/createDatabaseRoutes/storages/File/FileWriter.mjs

@@ -0,0 +1,43 @@
+import fs from "node:fs";
+//#region src/core/database/createDatabaseRoutes/storages/File/FileWriter.ts
+var FileWriter = class {
+	filePath;
+	nextData = null;
+	nextDataPromise = null;
+	nextDataResolve = null;
+	writeIsLocked = false;
+	constructor(filePath) {
+		this.filePath = filePath;
+	}
+	lockedWrite(data) {
+		this.nextData = data;
+		this.nextDataPromise = this.nextDataPromise ?? new Promise((resolve) => {
+			this.nextDataResolve = resolve;
+		});
+		return new Promise((resolve) => {
+			this.nextDataPromise?.then(() => {
+				resolve();
+			});
+		});
+	}
+	async unlockedWrite(data, recursionLevel = 0) {
+		this.writeIsLocked = true;
+		await fs.promises.writeFile(this.filePath, data, "utf-8");
+		this.writeIsLocked = false;
+		const passedData = this.nextData;
+		this.nextData = null;
+		if (passedData) {
+			await this.unlockedWrite(passedData, recursionLevel + 1);
+			if (recursionLevel === 0) {
+				this.nextDataResolve?.();
+				this.nextDataPromise = null;
+				this.nextDataResolve = null;
+			}
+		}
+	}
+	write(data) {
+		return this.writeIsLocked ? this.lockedWrite(data) : this.unlockedWrite(data);
+	}
+};
+//#endregion
+export { FileWriter };

package/dist/src/core/database/createDatabaseRoutes/storages/Memory/MemoryStorage.mjs

@@ -0,0 +1,42 @@
+import { isIndex } from "../../helpers/array/isIndex/isIndex.mjs";
+import "../../helpers/index.mjs";
+//#region src/core/database/createDatabaseRoutes/storages/Memory/MemoryStorage.ts
+var MemoryStorage = class {
+	data;
+	constructor(initialData) {
+		this.data = initialData;
+	}
+	read(key) {
+		if (!key) return this.data;
+		const keys = Array.isArray(key) ? key : [key];
+		let readable = this.data;
+		for (const currentKey of keys) readable = readable[currentKey];
+		return readable;
+	}
+	write(key, value) {
+		const keys = Array.isArray(key) ? key : [key];
+		let writable = this.data;
+		let index = 0;
+		while (index < keys.length - 1) {
+			writable = writable[keys[index]];
+			index += 1;
+		}
+		writable[keys[index]] = value;
+	}
+	delete(key) {
+		const keys = Array.isArray(key) ? key : [key];
+		let deletable = this.data;
+		let index = 0;
+		while (index < keys.length - 1) {
+			deletable = deletable[keys[index]];
+			index += 1;
+		}
+		if (Array.isArray(deletable) && isIndex(keys[index])) {
+			deletable.splice(keys[index], 1);
+			return;
+		}
+		delete deletable[keys[index]];
+	}
+};
+//#endregion
+export { MemoryStorage };

package/dist/src/core/database/createDatabaseRoutes/storages/index.mjs

@@ -0,0 +1,3 @@
+import "./File/FileStorage.mjs";
+import "./Memory/MemoryStorage.mjs";
+export {};

package/dist/src/core/database/createOrm/createOrm.mjs

@@ -0,0 +1,96 @@
+import { createNewId } from "../createDatabaseRoutes/helpers/array/createNewId/createNewId.mjs";
+import { findIndexById } from "../createDatabaseRoutes/helpers/array/findIndexById/findIndexById.mjs";
+import { splitDatabaseByNesting } from "../createDatabaseRoutes/helpers/splitDatabaseByNesting/splitDatabaseByNesting.mjs";
+import "../createDatabaseRoutes/helpers/index.mjs";
+import { flatten } from "flat";
+//#region src/core/database/createOrm/createOrm.ts
+const createOrm = (storage) => {
+	const { shallowDatabase, nestedDatabase } = splitDatabaseByNesting(storage.read());
+	const nestedOrm = Object.keys(nestedDatabase).reduce((orm, key) => {
+		orm[key] = {
+			create: (item) => {
+				const collection = storage.read(key);
+				const newResourceId = createNewId(collection);
+				const newResource = {
+					...item,
+					id: newResourceId
+				};
+				storage.write([key, collection.length], newResource);
+				return newResource;
+			},
+			update: (id, item) => {
+				const currentResourceIndex = findIndexById(storage.read(key), id);
+				const updatedResource = {
+					...storage.read([key, currentResourceIndex]),
+					...item,
+					id
+				};
+				storage.write([key, currentResourceIndex], updatedResource);
+			},
+			delete: (id) => {
+				const currentResourceIndex = findIndexById(storage.read(key), id);
+				storage.delete([key, currentResourceIndex]);
+			},
+			createMany(items) {
+				items.forEach((item) => this.create(item));
+			},
+			updateMany(ids, item) {
+				ids.forEach((id) => this.update(id, item));
+				return ids.length;
+			},
+			deleteMany(ids) {
+				ids.forEach((id) => this.delete(id));
+			},
+			findById: (id) => {
+				const currentResourceIndex = findIndexById(storage.read(key), id);
+				return storage.read([key, currentResourceIndex]);
+			},
+			findMany: (filters) => {
+				const collection = storage.read(key);
+				if (!filters) return collection;
+				const flattenedFilters = flatten(filters);
+				return collection.filter((resource) => {
+					const flattenedResource = flatten(resource);
+					return Object.entries(flattenedFilters).every(([key, value]) => flattenedResource[key] === value);
+				});
+			},
+			findFirst: (filters) => {
+				const collection = storage.read(key);
+				if (!filters) return collection[0];
+				const flattenedFilters = flatten(filters);
+				return collection.find((resource) => {
+					const flattenedResource = flatten(resource);
+					return Object.entries(flattenedFilters).every(([key, value]) => flattenedResource[key] === value);
+				});
+			},
+			exists: (filters) => {
+				const collection = storage.read(key);
+				const flattenedFilters = flatten(filters);
+				return collection.some((resource) => {
+					const flattenedResource = flatten(resource);
+					return Object.entries(flattenedFilters).every(([key, value]) => flattenedResource[key] === value);
+				});
+			},
+			count: () => storage.read(key).length
+		};
+		orm[key].createMany = orm[key].createMany.bind(orm[key]);
+		orm[key].updateMany = orm[key].updateMany.bind(orm[key]);
+		orm[key].deleteMany = orm[key].deleteMany.bind(orm[key]);
+		return orm;
+	}, {});
+	const shallowOrm = Object.keys(shallowDatabase).reduce((orm, key) => {
+		orm[key] = {
+			get: () => storage.read(key),
+			update: (data) => {
+				storage.write(key, data);
+			}
+		};
+		return orm;
+	}, {});
+	return {
+		...nestedOrm,
+		...shallowOrm
+	};
+};
+//#endregion
+export { createOrm };

package/dist/src/core/database/createStorage/createStorage.mjs

@@ -0,0 +1,8 @@
+import { FileStorage } from "../createDatabaseRoutes/storages/File/FileStorage.mjs";
+import { MemoryStorage } from "../createDatabaseRoutes/storages/Memory/MemoryStorage.mjs";
+import "../createDatabaseRoutes/storages/index.mjs";
+//#region src/core/database/createStorage/createStorage.ts
+const isVariableJsonFile = (variable) => typeof variable === "string" && variable.endsWith(".json");
+const createStorage = (data) => isVariableJsonFile(data) ? new FileStorage(data) : new MemoryStorage(data);
+//#endregion
+export { createStorage };

package/dist/src/core/database/index.mjs

@@ -0,0 +1,4 @@
+import "./createStorage/createStorage.mjs";
+import "./createDatabaseRoutes/createDatabaseRoutes.mjs";
+import "./createOrm/createOrm.mjs";
+export {};

package/dist/src/core/entities/handlers/endsWith.d.mts

@@ -0,0 +1,5 @@
+import { Comparator } from "../../../utils/types/entities.mjs";
+//#region src/core/entities/handlers/endsWith.d.ts
+declare const endsWith: (expected: unknown) => Comparator;
+//#endregion
+export { endsWith };

package/dist/src/core/entities/handlers/endsWith.mjs

@@ -0,0 +1,6 @@
+import { createComparator } from "../../../utils/helpers/entities/createComparator/createComparator.mjs";
+import "../../../utils/helpers/index.mjs";
+//#region src/core/entities/handlers/endsWith.ts
+const endsWith = (expected) => createComparator((actual, { endsWith }) => endsWith(actual, expected));
+//#endregion
+export { endsWith };

package/dist/src/core/entities/handlers/equals.d.mts

@@ -0,0 +1,5 @@
+import { Comparator } from "../../../utils/types/entities.mjs";
+//#region src/core/entities/handlers/equals.d.ts
+declare const equals: (expected: unknown) => Comparator;
+//#endregion
+export { equals };

package/dist/src/core/entities/handlers/equals.mjs

@@ -0,0 +1,6 @@
+import { createComparator } from "../../../utils/helpers/entities/createComparator/createComparator.mjs";
+import "../../../utils/helpers/index.mjs";
+//#region src/core/entities/handlers/equals.ts
+const equals = (expected) => createComparator((actual, { equals }) => equals(actual, expected));
+//#endregion
+export { equals };

package/dist/src/core/entities/handlers/every.d.mts

@@ -0,0 +1,5 @@
+import { Comparator } from "../../../utils/types/entities.mjs";
+//#region src/core/entities/handlers/every.d.ts
+declare const every: (...comparators: Comparator[]) => Comparator;
+//#endregion
+export { every };

package/dist/src/core/entities/handlers/every.mjs

@@ -0,0 +1,6 @@
+import { createComparator } from "../../../utils/helpers/entities/createComparator/createComparator.mjs";
+import "../../../utils/helpers/index.mjs";
+//#region src/core/entities/handlers/every.ts
+const every = (...comparators) => createComparator((actual, { fn }) => comparators.every((comparator) => fn(actual, comparator)));
+//#endregion
+export { every };

package/dist/src/core/entities/handlers/exists.d.mts

@@ -0,0 +1,5 @@
+import { Comparator } from "../../../utils/types/entities.mjs";
+//#region src/core/entities/handlers/exists.d.ts
+declare const exists: () => Comparator;
+//#endregion
+export { exists };

package/dist/src/core/entities/handlers/exists.mjs

@@ -0,0 +1,6 @@
+import { createComparator } from "../../../utils/helpers/entities/createComparator/createComparator.mjs";
+import "../../../utils/helpers/index.mjs";
+//#region src/core/entities/handlers/exists.ts
+const exists = () => createComparator((actual, { exists }) => exists(actual));
+//#endregion
+export { exists };

package/dist/src/core/entities/handlers/fn.d.mts

@@ -0,0 +1,6 @@
+import { Comparator } from "../../../utils/types/entities.mjs";
+import { FnComparator } from "../../../utils/helpers/entities/resolveEntityValues/resolveEntityValues.mjs";
+//#region src/core/entities/handlers/fn.d.ts
+declare const fn: (comparator: FnComparator) => Comparator;
+//#endregion
+export { fn };

package/dist/src/core/entities/handlers/fn.mjs

@@ -0,0 +1,6 @@
+import { createComparator } from "../../../utils/helpers/entities/createComparator/createComparator.mjs";
+import "../../../utils/helpers/index.mjs";
+//#region src/core/entities/handlers/fn.ts
+const fn = (comparator) => createComparator((actual, { fn }) => fn(actual, createComparator(comparator)));
+//#endregion
+export { fn };

package/dist/src/core/entities/handlers/greater.d.mts

@@ -0,0 +1,5 @@
+import { Comparator } from "../../../utils/types/entities.mjs";
+//#region src/core/entities/handlers/greater.d.ts
+declare const greater: (expected: number) => Comparator;
+//#endregion
+export { greater };

package/dist/src/core/entities/handlers/greater.mjs

@@ -0,0 +1,6 @@
+import { createComparator } from "../../../utils/helpers/entities/createComparator/createComparator.mjs";
+import "../../../utils/helpers/index.mjs";
+//#region src/core/entities/handlers/greater.ts
+const greater = (expected) => createComparator((actual, { greater }) => greater(actual, expected));
+//#endregion
+export { greater };

package/dist/src/core/entities/handlers/greaterOrEquals.d.mts

@@ -0,0 +1,5 @@
+import { Comparator } from "../../../utils/types/entities.mjs";
+//#region src/core/entities/handlers/greaterOrEquals.d.ts
+declare const greaterOrEquals: (expected: number) => Comparator;
+//#endregion
+export { greaterOrEquals };

package/dist/src/core/entities/handlers/greaterOrEquals.mjs

@@ -0,0 +1,6 @@
+import { createComparator } from "../../../utils/helpers/entities/createComparator/createComparator.mjs";
+import "../../../utils/helpers/index.mjs";
+//#region src/core/entities/handlers/greaterOrEquals.ts
+const greaterOrEquals = (expected) => createComparator((actual, { greaterOrEquals }) => greaterOrEquals(actual, expected));
+//#endregion
+export { greaterOrEquals };

package/dist/src/core/entities/handlers/haveEntries.d.mts

@@ -0,0 +1,6 @@
+import { Comparator } from "../../../utils/types/entities.mjs";
+import { PlainObject } from "../../../utils/types/values.mjs";
+//#region src/core/entities/handlers/haveEntries.d.ts
+declare const haveEntries: (entry: any[] | PlainObject) => Comparator;
+//#endregion
+export { haveEntries };

package/dist/src/core/entities/handlers/haveEntries.mjs

@@ -0,0 +1,6 @@
+import { createComparator } from "../../../utils/helpers/entities/createComparator/createComparator.mjs";
+import "../../../utils/helpers/index.mjs";
+//#region src/core/entities/handlers/haveEntries.ts
+const haveEntries = (entry) => createComparator((actual, { haveEntries }) => haveEntries(actual, entry));
+//#endregion
+export { haveEntries };

package/dist/src/core/entities/handlers/haveType.d.mts

@@ -0,0 +1,6 @@
+import { Comparator } from "../../../utils/types/entities.mjs";
+import { HaveTypeType } from "../../../utils/helpers/entities/resolveEntityValues/resolveEntityValues.mjs";
+//#region src/core/entities/handlers/haveType.d.ts
+declare const haveType: (type: HaveTypeType) => Comparator;
+//#endregion
+export { haveType };

package/dist/src/core/entities/handlers/haveType.mjs

@@ -0,0 +1,6 @@
+import { createComparator } from "../../../utils/helpers/entities/createComparator/createComparator.mjs";
+import "../../../utils/helpers/index.mjs";
+//#region src/core/entities/handlers/haveType.ts
+const haveType = (type) => createComparator((actual, { haveType }) => haveType(actual, type));
+//#endregion
+export { haveType };

package/dist/src/core/entities/handlers/inRange.d.mts

@@ -0,0 +1,5 @@
+import { Comparator } from "../../../utils/types/entities.mjs";
+//#region src/core/entities/handlers/inRange.d.ts
+declare const inRange: (range: [number, number]) => Comparator;
+//#endregion
+export { inRange };

package/dist/src/core/entities/handlers/inRange.mjs

@@ -0,0 +1,6 @@
+import { createComparator } from "../../../utils/helpers/entities/createComparator/createComparator.mjs";
+import "../../../utils/helpers/index.mjs";
+//#region src/core/entities/handlers/inRange.ts
+const inRange = (range) => createComparator((actual, { inRange }) => inRange(actual, range));
+//#endregion
+export { inRange };

package/dist/src/core/entities/handlers/includes.d.mts

@@ -0,0 +1,5 @@
+import { Comparator } from "../../../utils/types/entities.mjs";
+//#region src/core/entities/handlers/includes.d.ts
+declare const includes: (expected: unknown) => Comparator;
+//#endregion
+export { includes };

package/dist/src/core/entities/handlers/includes.mjs

@@ -0,0 +1,6 @@
+import { createComparator } from "../../../utils/helpers/entities/createComparator/createComparator.mjs";
+import "../../../utils/helpers/index.mjs";
+//#region src/core/entities/handlers/includes.ts
+const includes = (expected) => createComparator((actual, { includes }) => includes(actual, expected));
+//#endregion
+export { includes };