@ucdjs/test-utils 1.0.1-beta.1

package/dist/index.d.mts

@@ -0,0 +1,76 @@
+import { n as unsafeResponse, o as MockStoreConfig, t as configure } from "./helpers-D3XLw9D1.mjs";
+import { mockStoreApi } from "./mock-store.mjs";
+
+//#region src/async.d.ts
+/**
+ * Collects all values from an async iterable into an array.
+ *
+ * This function consumes an async iterable and collects all emitted values into
+ * a regular array. If the async iterable throws an error at any point, the error
+ * is propagated after the iterator's `return()` method is called (if available)
+ * to allow for cleanup.
+ *
+ * @typeParam T - The type of values yielded by the async iterable.
+ * @param {AsyncIterable<T>} iterable - The async iterable to consume completely.
+ * @returns {Promise<T[]>} A promise that resolves to an array containing all values in emission order.
+ * @throws {Error} Propagates any error thrown by the async iterable.
+ *
+ * @example
+ * ```ts
+ * const values = await collect(asyncFromArray([1, 2, 3]));
+ * console.assert(values.equals([1, 2, 3]));
+ * ```
+ *
+ * @example Cleanup on error
+ * ```ts
+ * async function* source() {
+ *   try {
+ *     yield 1;
+ *     throw new Error('boom');
+ *   } finally {
+ *     console.log('Cleanup!'); // Called even though an error was thrown
+ *   }
+ * }
+ * await collect(source()); // throws, but cleanup runs first
+ * ```
+ */
+declare function collect<T>(iterable: AsyncIterable<T>): Promise<T[]>;
+/**
+ * Wraps a synchronous iterable as an async iterable.
+ *
+ * This is useful in tests when you want to simulate an async source but only have
+ * synchronous data. The resulting async iterable properly implements the async
+ * iterator protocol, including support for cleanup via `return()`.
+ *
+ * @typeParam T - The type of elements in the iterable.
+ * @param {Iterable<T>} iterable - A synchronous iterable (array, Set, Map, etc.) to wrap.
+ * @param {object} [options] - Optional configuration.
+ * @param {number} [options.delay] - Number of milliseconds to wait before each value is yielded.
+ *                        Useful for simulating network latency or slow producers in tests.
+ *                        Must be a non-negative number.
+ * @returns {AsyncIterable<T>} An async iterable that yields each element from the source iterable.
+ *
+ * @example
+ * ```ts
+ * // Simple case: wrap an array
+ * for await (const value of asyncFromArray([1, 2, 3])) {
+ *   console.log(value);
+ * }
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Simulate network latency (50ms between values)
+ * for await (const value of asyncFromArray(['a', 'b', 'c'], { delay: 50 })) {
+ *   console.log(value);
+ * }
+ * ```
+ */
+declare function asyncFromArray<T>(iterable: Iterable<T>, options?: {
+  readonly delay?: number;
+}): AsyncIterable<T>;
+//#endregion
+//#region src/index.d.ts
+declare function encodeBase64(content: string): string;
+//#endregion
+export { type MockStoreConfig, asyncFromArray, collect, configure, encodeBase64, mockStoreApi, unsafeResponse };

package/dist/index.mjs

@@ -0,0 +1,89 @@
+import { c as unsafeResponse, s as configure } from "./file-tree-CColHWG6.mjs";
+import { mockStoreApi } from "./mock-store.mjs";
+
+//#region src/async.ts
+/**
+* Collects all values from an async iterable into an array.
+*
+* This function consumes an async iterable and collects all emitted values into
+* a regular array. If the async iterable throws an error at any point, the error
+* is propagated after the iterator's `return()` method is called (if available)
+* to allow for cleanup.
+*
+* @typeParam T - The type of values yielded by the async iterable.
+* @param {AsyncIterable<T>} iterable - The async iterable to consume completely.
+* @returns {Promise<T[]>} A promise that resolves to an array containing all values in emission order.
+* @throws {Error} Propagates any error thrown by the async iterable.
+*
+* @example
+* ```ts
+* const values = await collect(asyncFromArray([1, 2, 3]));
+* console.assert(values.equals([1, 2, 3]));
+* ```
+*
+* @example Cleanup on error
+* ```ts
+* async function* source() {
+*   try {
+*     yield 1;
+*     throw new Error('boom');
+*   } finally {
+*     console.log('Cleanup!'); // Called even though an error was thrown
+*   }
+* }
+* await collect(source()); // throws, but cleanup runs first
+* ```
+*/
+async function collect(iterable) {
+	const result = [];
+	for await (const value of iterable) result.push(value);
+	return result;
+}
+/**
+* Wraps a synchronous iterable as an async iterable.
+*
+* This is useful in tests when you want to simulate an async source but only have
+* synchronous data. The resulting async iterable properly implements the async
+* iterator protocol, including support for cleanup via `return()`.
+*
+* @typeParam T - The type of elements in the iterable.
+* @param {Iterable<T>} iterable - A synchronous iterable (array, Set, Map, etc.) to wrap.
+* @param {object} [options] - Optional configuration.
+* @param {number} [options.delay] - Number of milliseconds to wait before each value is yielded.
+*                        Useful for simulating network latency or slow producers in tests.
+*                        Must be a non-negative number.
+* @returns {AsyncIterable<T>} An async iterable that yields each element from the source iterable.
+*
+* @example
+* ```ts
+* // Simple case: wrap an array
+* for await (const value of asyncFromArray([1, 2, 3])) {
+*   console.log(value);
+* }
+* ```
+*
+* @example
+* ```ts
+* // Simulate network latency (50ms between values)
+* for await (const value of asyncFromArray(['a', 'b', 'c'], { delay: 50 })) {
+*   console.log(value);
+* }
+* ```
+*/
+function asyncFromArray(iterable, options) {
+	return (async function* () {
+		for (const value of iterable) {
+			if (options?.delay) await new Promise((resolve) => setTimeout(resolve, options.delay));
+			yield value;
+		}
+	})();
+}
+
+//#endregion
+//#region src/index.ts
+function encodeBase64(content) {
+	return Buffer.from(content, "utf-8").toString("base64");
+}
+
+//#endregion
+export { asyncFromArray, collect, configure, encodeBase64, mockStoreApi, unsafeResponse };

package/dist/matchers/types.mjs

@@ -0,0 +1,149 @@
+import "vitest";
+import z$2 from "zod";
+import "@vitest/expect";
+
+//#region src/matchers/error-matchers.d.ts
+var ErrorMatcherOptions = [
+	30,
+	() => [
+		Error,
+		RegExp,
+		Error,
+		Record
+	],
+	[
+		"",
+		"",
+		"",
+		"",
+		"",
+		"",
+		"",
+		"",
+		"",
+		""
+	]
+];
+
+//#endregion
+//#region src/matchers/response-matchers.d.ts
+var ApiErrorOptions = [
+	25,
+	() => [RegExp],
+	[
+		"",
+		"",
+		""
+	]
+];
+var ResponseMatcherOptions = [
+	28,
+	() => [
+		RegExp,
+		Record,
+		RegExp,
+		RegExp
+	],
+	[
+		"",
+		"",
+		"",
+		"",
+		"",
+		"",
+		"",
+		"",
+		"",
+		"",
+		""
+	]
+];
+
+//#endregion
+//#region src/matchers/schema-matchers.d.ts
+var SchemaMatcherOptions = [
+	23,
+	(TSchema) => [
+		z$2.ZodType,
+		TSchema,
+		TSchema,
+		z$2.infer,
+		Partial
+	],
+	[
+		"",
+		"",
+		"",
+		"",
+		"",
+		"",
+		"",
+		"",
+		"",
+		"",
+		""
+	]
+];
+
+//#endregion
+//#region src/matchers/types.d.ts
+var CustomMatchers = [
+	0,
+	(TSchema, R) => [
+		ErrorMatcherOptions,
+		R,
+		z.ZodType,
+		TSchema,
+		SchemaMatcherOptions,
+		R,
+		ApiErrorOptions,
+		R,
+		Promise,
+		R,
+		ResponseMatcherOptions,
+		R,
+		Promise
+	],
+	[
+		"",
+		"",
+		"",
+		"",
+		"",
+		"",
+		"",
+		"",
+		"",
+		"",
+		"",
+		"",
+		"",
+		"",
+		"",
+		"",
+		"",
+		"",
+		"",
+		"",
+		"",
+		"",
+		"",
+		"",
+		"",
+		""
+	]
+];
+var _0 = [
+	1,
+	(T) => [T, CustomMatchers],
+	[
+		"",
+		"",
+		"",
+		""
+	],
+	sideEffect(_0)
+];
+
+//#endregion
+export {  };

package/dist/matchers/vitest-setup.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/matchers/vitest-setup.mjs

@@ -0,0 +1,239 @@
+import { tryOr } from "@ucdjs-internal/shared";
+import { expect } from "vitest";
+
+//#region src/matchers/error-matchers.ts
+const toMatchError = function(received, options) {
+	let error = null;
+	if (typeof received === "function") try {
+		received();
+		return {
+			pass: false,
+			message: () => "Expected function to throw an error, but it did not"
+		};
+	} catch (e) {
+		if (!(e instanceof Error)) return {
+			pass: false,
+			message: () => `Expected function to throw an Error, but it threw ${typeof e}`
+		};
+		error = e;
+	}
+	else if (received instanceof Error) error = received;
+	else return {
+		pass: false,
+		message: () => `Expected an Error instance or a function that throws, but received ${typeof received}`
+	};
+	const errorName = error.constructor.name;
+	if (options.type && !(error instanceof options.type)) return {
+		pass: false,
+		message: () => `Expected error to be instance of ${options.type.name}, but got ${errorName}`
+	};
+	if (options.message) {
+		if (!(typeof options.message === "string" ? error.message === options.message : options.message.test(error.message))) return {
+			pass: false,
+			message: () => `Expected error message to match ${options.message}, but got "${error.message}"`
+		};
+	}
+	if (options.cause) {
+		const causeError = error.cause ?? error.originalError;
+		if (!causeError) return {
+			pass: false,
+			message: () => `Expected error to have a cause, but none was found`
+		};
+		if (!(causeError instanceof options.cause)) {
+			const causeName = causeError instanceof Error ? causeError.constructor.name : typeof causeError;
+			return {
+				pass: false,
+				message: () => `Expected cause to be instance of ${options.cause.name}, but got ${causeName}`
+			};
+		}
+	}
+	if (options.fields) {
+		const errorRecord = error;
+		for (const [key, expectedValue] of Object.entries(options.fields)) {
+			const actualValue = errorRecord[key];
+			if (!(typeof expectedValue === "object" && expectedValue !== null ? JSON.stringify(actualValue) === JSON.stringify(expectedValue) : actualValue === expectedValue)) return {
+				pass: false,
+				message: () => `Expected error.${key} to be ${JSON.stringify(expectedValue)}, but got ${JSON.stringify(actualValue)}`
+			};
+		}
+	}
+	return {
+		pass: true,
+		message: () => `Expected error not to match the given criteria`
+	};
+};
+
+//#endregion
+//#region src/matchers/response-matchers.ts
+const toBeApiError = async function(received, options) {
+	const { isNot, equals } = this;
+	if (!equals(received.status, options.status)) return {
+		pass: false,
+		message: () => `Expected response to${isNot ? " not" : ""} be an API error with status ${options.status}, but got ${received.status}`
+	};
+	if (!received.headers.get("content-type")?.includes("application/json")) return {
+		pass: false,
+		message: () => `Expected response to${isNot ? " not" : ""} have application/json content-type`
+	};
+	const error = await received.json();
+	if (!error.status || !error.message || !error.timestamp) return {
+		pass: false,
+		message: () => `Expected response to${isNot ? " not" : ""} have status, message, and timestamp properties`
+	};
+	if (options.message) {
+		if (!(typeof options.message === "string" ? error.message === options.message : options.message.test(error.message))) {
+			const expectedMsg = typeof options.message === "string" ? options.message : options.message.source;
+			return {
+				pass: false,
+				message: () => `Expected error message to${isNot ? " not" : ""} match ${expectedMsg}, but got "${error.message}"`
+			};
+		}
+	}
+	return {
+		pass: true,
+		message: () => `Expected response to${isNot ? " not" : ""} be an API error`
+	};
+};
+const toBeHeadError = function(received, expectedStatus) {
+	const { isNot, equals } = this;
+	if (!equals(received.status, expectedStatus)) return {
+		pass: false,
+		message: () => `Expected HEAD response status to${isNot ? " not" : ""} be ${expectedStatus}, but got ${received.status}`
+	};
+	const contentLength = received.headers.get("content-length");
+	if (contentLength !== null && Number.parseInt(contentLength, 10) !== 0) return {
+		pass: false,
+		message: () => `Expected HEAD response to${isNot ? " not" : ""} have content-length of 0`
+	};
+	return {
+		pass: true,
+		message: () => `Expected HEAD response to${isNot ? " not" : ""} have status ${expectedStatus}`
+	};
+};
+const toMatchResponse = async function(received, options) {
+	const { isNot, equals } = this;
+	if (options.status !== void 0 && !equals(received.status, options.status)) return {
+		pass: false,
+		message: () => `Expected status to${isNot ? " not" : ""} be ${options.status}, but got ${received.status}`
+	};
+	const isJson = received.headers.get("content-type")?.includes("application/json");
+	if (options.json && !isJson) return {
+		pass: false,
+		message: () => `Expected response to${isNot ? " not" : ""} have application/json content-type`
+	};
+	if (options.cache) {
+		const cacheControl = received.headers.get("cache-control");
+		if (!cacheControl) return {
+			pass: false,
+			message: () => `Expected response to${isNot ? " not" : ""} have cache-control header`
+		};
+		if (options.cacheMaxAgePattern && !options.cacheMaxAgePattern.test(cacheControl)) return {
+			pass: false,
+			message: () => `Expected cache-control to${isNot ? " not" : ""} match ${options.cacheMaxAgePattern.source}`
+		};
+		if (!options.cacheMaxAgePattern && !/max-age=\d+/.test(cacheControl)) return {
+			pass: false,
+			message: () => `Expected cache-control to${isNot ? " not" : ""} have max-age`
+		};
+	}
+	if (options.headers) for (const [key, value] of Object.entries(options.headers)) {
+		const headerValue = received.headers.get(key);
+		if (!headerValue) return {
+			pass: false,
+			message: () => `Expected response to${isNot ? " not" : ""} have ${key} header`
+		};
+		if (!(typeof value === "string" ? equals(headerValue, value) : value.test(headerValue))) {
+			const expected = typeof value === "string" ? value : value.source;
+			return {
+				pass: false,
+				message: () => `Expected ${key} header to${isNot ? " not" : ""} match ${expected}, but got "${headerValue}"`
+			};
+		}
+	}
+	if (options.error) {
+		if (!isJson) return {
+			pass: false,
+			message: () => `Expected error response to${isNot ? " not" : ""} have application/json content-type`
+		};
+		const error = await tryOr({
+			try: async () => received.json(),
+			err(err) {
+				console.error("Failed to parse response JSON:", err);
+				return null;
+			}
+		});
+		if (error == null) return {
+			pass: false,
+			message: () => `Expected response body to${isNot ? " not" : ""} be valid JSON`
+		};
+		if (!error.status) return {
+			pass: false,
+			message: () => `Expected error to${isNot ? " not" : ""} have "status" property`
+		};
+		if (!error.message) return {
+			pass: false,
+			message: () => `Expected error to${isNot ? " not" : ""} have "message" property`
+		};
+		if (!error.timestamp) return {
+			pass: false,
+			message: () => `Expected error to${isNot ? " not" : ""} have "timestamp" property`
+		};
+		if (options.status !== void 0 && !equals(error.status, options.status)) return {
+			pass: false,
+			message: () => `Expected error.status to${isNot ? " not" : ""} be ${options.status}, but got ${error.status}`
+		};
+		if (options.error.message) {
+			if (!(options.error.message instanceof RegExp ? options.error.message.test(error.message) : equals(error.message, options.error.message))) {
+				const expectedMsg = typeof options.error.message === "string" ? options.error.message : options.error.message.source;
+				return {
+					pass: false,
+					message: () => `Expected error.message to${isNot ? " not" : ""} match "${expectedMsg}", but got "${error.message}"`
+				};
+			}
+		}
+	}
+	return {
+		pass: true,
+		message: () => `Expected response to${isNot ? " not" : ""} match the given criteria`
+	};
+};
+
+//#endregion
+//#region src/matchers/schema-matchers.ts
+const toMatchSchema = function(received, options) {
+	const result = options.schema.safeParse(received);
+	if (!(result.success === options.success)) {
+		const expectedStatus = options.success ? "succeed" : "fail";
+		const actualStatus = result.success ? "succeeded" : "failed";
+		const issues = result.error?.issues ? `\n${this.utils.printExpected(result.error.issues)}` : "";
+		return {
+			pass: false,
+			message: () => `Expected schema validation to ${expectedStatus}, but it ${actualStatus}${issues}`
+		};
+	}
+	if (options.data && result.success) for (const key of Object.keys(options.data)) {
+		const expected = options.data[key];
+		const received = result.data[key];
+		if (!this.equals(received, expected)) return {
+			pass: false,
+			message: () => `Expected property "${key}" to equal ${this.utils.printExpected(expected)}, but received ${this.utils.printReceived(received)}`
+		};
+	}
+	return {
+		pass: true,
+		message: () => `Expected schema validation to not match`
+	};
+};
+
+//#endregion
+//#region src/matchers/vitest-setup.ts
+expect.extend({
+	toMatchError,
+	toMatchSchema,
+	toBeApiError,
+	toBeHeadError,
+	toMatchResponse
+});
+
+//#endregion
+export {  };

package/dist/mock-store.d.mts

@@ -0,0 +1,21 @@
+import { a as createFileTree, i as FileTreeNodeWithContent, n as unsafeResponse, o as MockStoreConfig, r as FileTreeInput, s as MockStoreFiles, t as configure } from "./helpers-D3XLw9D1.mjs";
+
+//#region src/mock-store/index.d.ts
+declare function mockStoreApi(config?: MockStoreConfig): void;
+/**
+ * Sets up mock handlers for the store subdomain (ucd-store.ucdjs.dev).
+ *
+ * This is used for the HTTP fs-bridge which directly accesses files via the store subdomain
+ * rather than through the API. The store subdomain handles paths like /:version/:filepath
+ * without the /ucd/ prefix (it's handled internally by the subdomain).
+ *
+ * @param {object} config - Configuration for the store subdomain mock
+ * @param {string} [config.storeBaseUrl] - Base URL for the store subdomain (defaults to https://ucd-store.ucdjs.dev)
+ * @param {MockStoreFiles} config.files - The files to mock
+ */
+declare function mockStoreSubdomain(config: {
+  storeBaseUrl?: string;
+  files: MockStoreFiles;
+}): void;
+//#endregion
+export { type FileTreeInput, type FileTreeNodeWithContent, type MockStoreConfig, configure, createFileTree, mockStoreApi, mockStoreSubdomain, unsafeResponse };