refactor: replace custom `flattenMessages` with simple `flatMap()`

	type MaybeAsyncCallback,

	diverge,

} from "../utils";

import { flattenMessages } from "../utils/flatten-messages";

function toHaveErrorImpl(

	context: MatcherContext,

	actual: Report,

	expected: Partial<Message>,

): MatcherResult {

	const flattened = flattenMessages(actual);

	const flattened = actual.results.flatMap((result) => result.messages);

	const matcher = [expect.objectContaining(expected)];

	const pass = context.equals(flattened, matcher);

	const diffString = context.utils.diff(matcher, flattened, { expand: context.expand });

	type MatcherResult,

	type MaybeAsyncCallback,

	diverge,

	flattenMessages,

} from "../utils";

function createMatcher(

		report: Report,

		errors: Array<[string, string] | Record<string, unknown>>,

	): MatcherResult {

		const flattened = flattenMessages(report);

		const flattened = report.results.flatMap((result) => result.messages);

		const matcher = errors.map((entry) => {

			if (Array.isArray(entry)) {

				const [ruleId, message] = entry;

import { type Message } from "../../message";

import { type Report, type Result } from "../../reporter";

/**

 * Takes all messages from all files and flattens to a single array.

 */

export function flattenMessages(report: Report): Message[] {

	return report.results.reduce((aggregated: Message[], result: Result) => {

		return aggregated.concat(result.messages);

	}, []);

}

export { codeframe } from "./codeframe";

export { type MaybeAsyncCallback, diverge } from "./diverge";

export { flattenMessages } from "./flatten-messages";

export { isThenable } from "./is-thenable";

export { type MatcherContext } from "./matcher-context";

export { type MatcherExpect } from "./matcher-expect";