@inlang/sdk 0.36.3 → 2.0.0-beta.1

package/src/createNewProject.test.ts

@@ -1,105 +0,0 @@
-import { describe, it, expect } from "vitest"
-import { createNewProject } from "./createNewProject.js"
-import { mockRepo } from "@lix-js/client"
-import { defaultProjectSettings } from "./defaultProjectSettings.js"
-import { loadProject } from "./loadProject.js"
-import { createMessage } from "./test-utilities/createMessage.js"
-import { sleep } from "./test-utilities/sleep.js"
-
-describe("createNewProject", () => {
-	it("should throw if a path does not end with .inlang", async () => {
-		const repo = await mockRepo()
-		const projectPath = "/test/project.inl"
-		try {
-			await createNewProject({ projectPath, repo, projectSettings: defaultProjectSettings })
-			// should not reach this point
-			throw new Error("Expected an error")
-		} catch (e) {
-			expect((e as Error).message).toMatch(
-				'Expected a path ending in "{name}.inlang" but received "/test/project.inl"'
-			)
-		}
-	})
-
-	it("should throw if projectPath is not an absolute path", async () => {
-		const repo = await mockRepo()
-		const projectPath = "test/project.inlang"
-		try {
-			await createNewProject({ projectPath, repo, projectSettings: defaultProjectSettings })
-			// should not reach this point
-			throw new Error("Expected an error")
-		} catch (e) {
-			expect((e as Error).message).toMatch(
-				'Expected an absolute path but received "test/project.inlang"'
-			)
-		}
-	})
-
-	it("should throw if the path already exists", async () => {
-		const repo = await mockRepo()
-		const projectPath = "/test/project.inlang"
-		await repo.nodeishFs.mkdir(projectPath, { recursive: true })
-		try {
-			await createNewProject({ projectPath, repo, projectSettings: defaultProjectSettings })
-			// should not reach this point
-			throw new Error("Expected an error")
-		} catch (e) {
-			expect((e as Error).message).toMatch(
-				'projectPath already exists, received "/test/project.inlang"'
-			)
-		}
-	})
-
-	it("should create default defaultProjectSettings in projectPath", async () => {
-		const repo = await mockRepo()
-		const projectPath = "/test/project.inlang"
-		await createNewProject({ projectPath, repo, projectSettings: defaultProjectSettings })
-		const json = await repo.nodeishFs.readFile(`${projectPath}/settings.json`, {
-			encoding: "utf-8",
-		})
-		const settings = JSON.parse(json)
-		expect(settings).toEqual(defaultProjectSettings)
-	})
-
-	it("should create different projectSettings in projectPath", async () => {
-		const repo = await mockRepo()
-		const projectPath = "/test/project.inlang"
-		const projectSettings = { ...defaultProjectSettings, languageTags: ["en", "de", "fr"] }
-		await createNewProject({ projectPath, repo, projectSettings })
-		const json = await repo.nodeishFs.readFile(`${projectPath}/settings.json`, {
-			encoding: "utf-8",
-		})
-		const settings = JSON.parse(json)
-		expect(settings).toEqual(projectSettings)
-		expect(settings).not.toEqual(defaultProjectSettings)
-	})
-
-	it("should load the project after creating it", async () => {
-		const repo = await mockRepo()
-		const projectPath = "/test/project.inlang"
-		await createNewProject({ projectPath, repo, projectSettings: defaultProjectSettings })
-
-		const project = await loadProject({ projectPath, repo })
-		expect(project.errors()).toEqual([])
-	})
-
-	it("should create messages inside the project directory", async () => {
-		const repo = await mockRepo()
-		const projectPath = "/test/project.inlang"
-		await createNewProject({ projectPath, repo, projectSettings: defaultProjectSettings })
-		const project = await loadProject({ projectPath, repo })
-		expect(project.errors()).toEqual([])
-
-		const testMessage = createMessage("test", { en: "test message" })
-		project.query.messages.create({ data: testMessage })
-		const messages = project.query.messages.getAll()
-		expect(messages.length).toBe(1)
-		expect(messages[0]).toEqual(testMessage)
-
-		await sleep(20)
-
-		const json = await repo.nodeishFs.readFile("/test/messages/en.json", { encoding: "utf-8" })
-		const jsonMessages = JSON.parse(json)
-		expect(jsonMessages["test"]).toEqual("test message")
-	})
-})

package/src/createNewProject.ts

@@ -1,46 +0,0 @@
-import type { Repository } from "@lix-js/client"
-import type { NodeishFilesystem } from "@lix-js/fs"
-import { ProjectSettings } from "@inlang/project-settings"
-import { assertValidProjectPath } from "./validateProjectPath.js"
-import { defaultProjectSettings } from "./defaultProjectSettings.js"
-
-/**
- * Creates a new project in the given directory.
- * The directory must be an absolute path, must not exist, and must end with {name}.inlang
- */
-export async function createNewProject(args: {
-	projectPath: string
-	repo: Repository
-	projectSettings: ProjectSettings
-}): Promise<void> {
-	assertValidProjectPath(args.projectPath)
-
-	const nodeishFs = args.repo.nodeishFs
-	if (await directoryExists(args.projectPath, nodeishFs)) {
-		throw new Error(`projectPath already exists, received "${args.projectPath}"`)
-	}
-	const settingsText = JSON.stringify(args.projectSettings ?? defaultProjectSettings, undefined, 2)
-
-	await nodeishFs.mkdir(args.projectPath, { recursive: true })
-	await Promise.all([
-		nodeishFs.writeFile(`${args.projectPath}/settings.json`, settingsText),
-		nodeishFs.writeFile(`${args.projectPath}/.gitignore`, "cache"),
-		nodeishFs.mkdir(`${args.projectPath}/cache/modules`, { recursive: true }),
-	])
-}
-
-/**
- * Returns true if the path exists (file or directory), false otherwise.
- */
-async function directoryExists(filePath: string, nodeishFs: NodeishFilesystem) {
-	try {
-		const stat = await nodeishFs.stat(filePath)
-		return stat.isDirectory()
-	} catch (error: any) {
-		if (error && "code" in error && error.code === "ENOENT") {
-			return false
-		} else {
-			throw new Error(`Failed to check if path exists: ${error}`, { cause: error })
-		}
-	}
-}

package/src/createNodeishFsWithAbsolutePaths.test.ts

@@ -1,55 +0,0 @@
-import { it, expect, vi } from "vitest"
-import { createNodeishFsWithAbsolutePaths } from "./createNodeishFsWithAbsolutePaths.js"
-// import type { NodeishFilesystemSubset } from "./versionedInterfaces.js"
-import type { NodeishFilesystem } from "@lix-js/fs"
-
-it("throws an error if projectPath is not an absolute path", () => {
-	const relativePath = "relative/path"
-
-	expect(() =>
-		createNodeishFsWithAbsolutePaths({ projectPath: relativePath, nodeishFs: {} as any })
-	).toThrow()
-})
-
-it("intercepts paths correctly for readFile", async () => {
-	const projectPath = `/Users/samuel/Documents/paraglide/example/project.inlang`
-
-	const filePaths = [
-		["file.txt", `/Users/samuel/Documents/paraglide/example/file.txt`],
-		["./file.txt", `/Users/samuel/Documents/paraglide/example/file.txt`],
-		["./folder/file.txt", `/Users/samuel/Documents/paraglide/example/folder/file.txt`],
-		["../file.txt", `/Users/samuel/Documents/paraglide/file.txt`],
-		["../folder/file.txt", `/Users/samuel/Documents/paraglide/folder/file.txt`],
-		["../../file.txt", `/Users/samuel/Documents/file.txt`],
-		["../../../file.txt", `/Users/samuel/file.txt`],
-	]
-
-	const mockNodeishFs = {
-		readFile: vi.fn(),
-		readdir: vi.fn(),
-		mkdir: vi.fn(),
-		rmdir: vi.fn(),
-		writeFile: vi.fn(),
-		watch: vi.fn(),
-		rm: vi.fn(),
-		stat: vi.fn(),
-		lstat: vi.fn(),
-		symlink: vi.fn(),
-		unlink: vi.fn(),
-		readlink: vi.fn(),
-	} satisfies Record<keyof NodeishFilesystem, any>
-
-	const interceptedFs = createNodeishFsWithAbsolutePaths({
-		projectPath,
-		nodeishFs: mockNodeishFs,
-	})
-
-	for (const [path, expectedPath] of filePaths) {
-		for (const fn of Object.keys(mockNodeishFs)) {
-			await interceptedFs[fn](path)
-			// @ts-expect-error
-			// expect the first argument to be the expectedPath
-			expect(mockNodeishFs[fn].mock.lastCall[0]).toBe(expectedPath)
-		}
-	}
-})

package/src/createNodeishFsWithAbsolutePaths.ts

@@ -1,52 +0,0 @@
-import { normalizePath, type NodeishFilesystem } from "@lix-js/fs"
-import { isAbsolutePath } from "./validateProjectPath.js"
-
-/**
- * Wraps the nodeish filesystem subset with a function that intercepts paths
- * and prepends the base path.
- *
- * The paths are resolved from the `projectPath` argument.
- */
-export const createNodeishFsWithAbsolutePaths = (args: {
-	projectPath: string
-	nodeishFs: NodeishFilesystem
-}): NodeishFilesystem => {
-	if (!isAbsolutePath(args.projectPath)) {
-		throw new Error(`Expected an absolute path but received "${args.projectPath}".`)
-	}
-
-	// get the base path of the settings file by
-	// removing the file name from the path
-	const basePath = normalizePath(args.projectPath).split("/").slice(0, -1).join("/")
-
-	const makeAbsolute = (path: string) => {
-		if (isAbsolutePath(path)) {
-			return normalizePath(path)
-		}
-
-		return normalizePath(basePath + "/" + path)
-	}
-
-	return {
-		// @ts-expect-error
-		readFile: (path: string, options: { encoding: "utf-8" | "binary" }) =>
-			args.nodeishFs.readFile(makeAbsolute(path), options),
-		readdir: (path: string) => args.nodeishFs.readdir(makeAbsolute(path)),
-		mkdir: (path: string, options: { recursive: boolean }) =>
-			args.nodeishFs.mkdir(makeAbsolute(path), options),
-		writeFile: (path: string, data: string) => args.nodeishFs.writeFile(makeAbsolute(path), data),
-		stat: (path: string) => args.nodeishFs.stat(makeAbsolute(path)),
-		rm: (path: string) => args.nodeishFs.rm(makeAbsolute(path)),
-		rmdir: (path: string) => (args.nodeishFs as any).rmdir(makeAbsolute(path)),
-		watch: (
-			path: string,
-			options: { signal: AbortSignal | undefined; recursive: boolean | undefined }
-		) => args.nodeishFs.watch(makeAbsolute(path), options),
-		// This might be surprising when symlinks were intended to be relative
-		symlink: (target: string, path: string) =>
-			args.nodeishFs.symlink(makeAbsolute(target), makeAbsolute(path)),
-		unlink: (path: string) => args.nodeishFs.unlink(makeAbsolute(path)),
-		readlink: (path: string) => args.nodeishFs.readlink(makeAbsolute(path)),
-		lstat: (path: string) => args.nodeishFs.lstat(makeAbsolute(path)),
-	}
-}

package/src/createNodeishFsWithWatcher.test.ts

@@ -1,50 +0,0 @@
-import { createNodeishMemoryFs } from "@lix-js/fs"
-import { describe, it, expect } from "vitest"
-import { createNodeishFsWithWatcher } from "./createNodeishFsWithWatcher.js"
-
-describe("watcher", () => {
-	it("should trigger the update function when file changes", async () => {
-		let counter = 0
-
-		const fs = createNodeishFsWithWatcher({
-			nodeishFs: createNodeishMemoryFs(),
-			onChange: () => {
-				counter++
-			},
-		})
-
-		// establish watcher
-		await fs.writeFile("file.txt", "a")
-		await fs.readFile("file.txt", { encoding: "utf-8" })
-		expect(counter).toBe(0)
-
-		// initial file change
-		await fs.writeFile("file.txt", "b")
-		await new Promise((resolve) => setTimeout(resolve, 0))
-
-		expect(counter).toBe(1)
-
-		// change file
-		await fs.writeFile("file.txt", "a")
-		await new Promise((resolve) => setTimeout(resolve, 0))
-
-		//check if update function was called
-		expect(counter).toBe(2)
-
-		// change file
-		await fs.readFile("file.txt")
-		await new Promise((resolve) => setTimeout(resolve, 0))
-
-		//check if update function was called
-		expect(counter).toBe(2)
-
-		fs.stopWatching()
-
-		// change file
-		await fs.writeFile("file.txt", "b")
-		await new Promise((resolve) => setTimeout(resolve, 0))
-
-		//check if update function was called - should not since signalled
-		expect(counter).toBe(2)
-	})
-})

package/src/createNodeishFsWithWatcher.ts

@@ -1,85 +0,0 @@
-import type { NodeishFilesystem } from "@lix-js/fs"
-
-/**
- * Wraps the nodeish filesystem subset with a function that intercepts paths
- * and prepends the base path.
- *
- * The paths are resolved from the `projectPath` argument.
- */
-export const createNodeishFsWithWatcher = (args: {
-	nodeishFs: NodeishFilesystem
-	onChange: () => void
-}): NodeishFilesystem & {
-	stopWatching: () => void
-} => {
-	const pathList = new Set<string>()
-	const abortControllers = new Set<AbortController>()
-
-	const stopWatching = () => {
-		for (const ac of abortControllers) {
-			ac.abort()
-			abortControllers.delete(ac) // release reference
-		}
-	}
-
-	const makeWatcher = async (path: string) => {
-		try {
-			const ac = new AbortController()
-			abortControllers.add(ac)
-			const watcher = args.nodeishFs.watch(path, {
-				signal: ac.signal,
-				recursive: true,
-				persistent: false,
-			})
-			if (watcher) {
-				//eslint-disable-next-line @typescript-eslint/no-unused-vars
-				for await (const event of watcher) {
-					// whenever the watcher changes we need to update the messages
-					args.onChange()
-				}
-			}
-		} catch (err: any) {
-			if (err.name === "AbortError") return
-			// https://github.com/opral/monorepo/issues/1647
-			// the file does not exist (yet)
-			// this is not testable beacause the fs.watch api differs
-			// from node and lix. lenghty
-			else if (err.code === "ENOENT") return
-			throw err
-		}
-	}
-
-	/**
-	 * Creates watchers on-the-fly for any file or directory that is not yet watched.
-	 *
-	 * We do this instead of recursively watching the entire project because fs.watch does not support
-	 * recursive watching on linux in node 18. Once node 18 support is dropped this can be drastically simplified.
-	 */
-	const watched = <T extends any[], R>(
-		fn: (path: string, ...rest: T) => R
-	): ((path: string, ...rest: T) => R) => {
-		return (path: string, ...rest: T): R => {
-			if (!pathList.has(path)) {
-				makeWatcher(path)
-				pathList.add(path)
-			}
-			return fn(path, ...rest)
-		}
-	}
-
-	return {
-		...args.nodeishFs,
-		/**
-		 * Reads the file and automatically adds it to the list of watched files.
-		 * Any changes to the file will trigger a message update.
-		 */
-		// @ts-expect-error
-		readFile: watched(args.nodeishFs.readFile),
-		/**
-		 * Reads the directory and automatically adds it to the list of watched files.
-		 * Any changes to the directory will trigger a message update.
-		 */
-		readdir: watched(args.nodeishFs.readdir),
-		stopWatching,
-	}
-}

package/src/defaultProjectSettings.ts

@@ -1,26 +0,0 @@
-import type { ProjectSettings } from "@inlang/project-settings"
-
-/**
- * Default project settings for createNewProject
- * from paraglide-js/src/cli/commands/init/defaults.ts
- */
-export const defaultProjectSettings = {
-	$schema: "https://inlang.com/schema/project-settings",
-	sourceLanguageTag: "en",
-	languageTags: ["en"],
-	modules: [
-		// for instant gratification, we're adding common rules
-		"https://cdn.jsdelivr.net/npm/@inlang/message-lint-rule-empty-pattern@latest/dist/index.js",
-		"https://cdn.jsdelivr.net/npm/@inlang/message-lint-rule-missing-translation@latest/dist/index.js",
-		"https://cdn.jsdelivr.net/npm/@inlang/message-lint-rule-without-source@latest/dist/index.js",
-
-		// default to the message format plugin because it supports all features
-		"https://cdn.jsdelivr.net/npm/@inlang/plugin-message-format@latest/dist/index.js",
-
-		// the m function matcher should be installed by default in case Sherlock (VS Code extension) is adopted
-		"https://cdn.jsdelivr.net/npm/@inlang/plugin-m-function-matcher@latest/dist/index.js",
-	],
-	"plugin.inlang.messageFormat": {
-		pathPattern: "./messages/{languageTag}.json",
-	},
-} satisfies ProjectSettings

package/src/env-variables/.prettierignore

@@ -1 +0,0 @@
-index.js

package/src/env-variables/createIndexFile.js

@@ -1,28 +0,0 @@
-/* eslint-disable no-restricted-imports */
-/* eslint-disable no-undef */
-/**
- * This script writes public environment variables
- * to an importable env file.
- *
- * - The SDK must bundle this file with the rest of the SDK
- * - This scripts avoids the need for a bundler
- * - Must be ran before building the SDK
- */
-
-import fs from "node:fs/promises"
-import url from "node:url"
-import path from "node:path"
-
-const dirname = path.dirname(url.fileURLToPath(import.meta.url))
-
-await fs.writeFile(
-	dirname + "/index.ts",
-	`
-export const ENV_VARIABLES = {
-  PUBLIC_POSTHOG_TOKEN: "${process.env.PUBLIC_POSTHOG_TOKEN}",
-}
-`
-)
-
-// eslint-disable-next-line no-console
-console.log("✅ Created env variable index file.")

package/src/errors.ts

@@ -1,84 +0,0 @@
-import type { SchemaOptions } from "@sinclair/typebox"
-import type { ValueError } from "@sinclair/typebox/errors"
-
-export class LoadProjectInvalidArgument extends Error {
-	constructor(message: string, options: { argument: string }) {
-		super(`The argument "${options.argument}" of loadProject() is invalid: ${message}`)
-		this.name = "LoadProjectInvalidArgument"
-	}
-}
-
-export class ProjectSettingsInvalidError extends Error {
-	constructor(options: { errors: ValueError[] }) {
-		// TODO: beatufiy ValueErrors
-		super(
-			`The project settings are invalid:
-${options.errors
-	.filter((error) => error.path)
-	.map(FormatProjectSettingsError)
-	.join("\n")}`
-		)
-		this.name = "ProjectSettingsInvalidError"
-	}
-}
-
-function FormatProjectSettingsError(error: ValueError) {
-	let msg = `${error.message} at ${error.path}`
-	if (error.path.startsWith("/modules/")) {
-		msg += `
-value = "${error.value}"
-- ${error.schema.allOf.map((o: SchemaOptions) => `${o.description ?? ""}`).join("\n- ")}`
-	}
-	return msg
-}
-
-export class ProjectSettingsFileJSONSyntaxError extends Error {
-	constructor(options: { cause: ErrorOptions["cause"]; path: string }) {
-		super(
-			`The settings file at "${options.path}" is not a valid JSON file:\n\n${options.cause}`,
-			options
-		)
-		this.name = "ProjectSettingsFileJSONSyntaxError"
-	}
-}
-
-export class ProjectSettingsFileNotFoundError extends Error {
-	constructor(options: { cause?: ErrorOptions["cause"]; path: string }) {
-		super(`The file at "${options.path}" could not be read. Does the file exists?`, options)
-		this.name = "ProjectSettingsFileNotFoundError"
-	}
-}
-
-export class PluginSaveMessagesError extends Error {
-	constructor(options: { cause: ErrorOptions["cause"] }) {
-		super(`An error occured in saveMessages() caused by ${options.cause}.`, options)
-		this.name = "PluginSaveMessagesError"
-	}
-}
-
-export class PluginLoadMessagesError extends Error {
-	constructor(options: { cause: ErrorOptions["cause"] }) {
-		super(`An error occured in loadMessages() caused by ${options.cause}.`, options)
-		this.name = "PluginLoadMessagesError"
-	}
-}
-
-export class LoadMessageError extends Error {
-	constructor(options: { path: string; messageId: string; cause: ErrorOptions["cause"] }) {
-		super(
-			`An error occured when loading message ${options.messageId} from path ${options.path} caused by ${options.cause}.`,
-			options
-		)
-		this.name = "LoadMessageError"
-	}
-}
-
-export class SaveMessageError extends Error {
-	constructor(options: { path: string; messageId: string; cause: ErrorOptions["cause"] }) {
-		super(
-			`An error occured when loading message ${options.messageId} from path ${options.path} caused by ${options.cause}.`,
-			options
-		)
-		this.name = "SaveMessageError"
-	}
-}

package/src/lint/index.ts

@@ -1,2 +0,0 @@
-export { lintSingleMessage } from "./message/lintSingleMessage.js"
-export { lintMessages } from "./message/lintMessages.js"

package/src/lint/message/errors.ts

@@ -1,9 +0,0 @@
-/**
- * Error when a lint rule throws during the linting process.
- */
-export class MessagedLintRuleThrowedError extends Error {
-	constructor(message: string, options?: ErrorOptions) {
-		super(message, options)
-		this.name = "MessagedLintRuleThrowedError"
-	}
-}

package/src/lint/message/lintMessages.test.ts

@@ -1,126 +0,0 @@
-import { beforeEach, describe, expect, test, vi } from "vitest"
-import { lintMessages } from "./lintMessages.js"
-import type { MessageLintReport, MessageLintRule } from "@inlang/message-lint-rule"
-import type { Message } from "@inlang/message"
-
-const lintRule1 = {
-	id: "messageLintRule.x.1",
-	displayName: { en: "" },
-	description: { en: "" },
-
-	run: vi.fn(),
-} satisfies MessageLintRule
-
-const lintRule2 = {
-	id: "messageLintRule.x.2",
-	displayName: { en: "" },
-	description: { en: "" },
-
-	run: vi.fn(),
-} satisfies MessageLintRule
-
-const message1 = { id: "m1" } as Message
-const message2 = { id: "m2" } as Message
-const message3 = { id: "m3" } as Message
-
-const messages = [message1, message2, message3]
-
-describe("lintMessages", async () => {
-	beforeEach(() => {
-		vi.resetAllMocks()
-	})
-
-	test("it should await all messages", async () => {
-		let called = 0
-		lintRule2.run.mockImplementation(async () => {
-			await new Promise((resolve) => setTimeout(resolve, 0))
-			called++
-		})
-
-		await lintMessages({
-			settings: {
-				sourceLanguageTag: "en",
-				languageTags: [],
-				modules: [],
-				messageLintRuleLevels: {
-					[lintRule1.id]: "warning",
-					[lintRule2.id]: "warning",
-				},
-			},
-			messages,
-			rules: [lintRule1, lintRule2],
-		})
-
-		expect(lintRule1.run).toHaveBeenCalledTimes(3)
-		expect(called).toBe(3)
-	})
-
-	test("it should process all messages and rules in parallel", async () => {
-		const fn = vi.fn()
-
-		lintRule1.run.mockImplementation(async ({ message }) => {
-			fn("r1", "before", message.id)
-			await new Promise((resolve) => setTimeout(resolve, 0))
-			fn("r1", "after", message.id)
-		})
-		lintRule2.run.mockImplementation(async ({ message }) => {
-			fn("r2", "before", message.id)
-			await new Promise((resolve) => setTimeout(resolve, 0))
-			fn("r2", "after", message.id)
-		})
-
-		await lintMessages({
-			settings: {
-				sourceLanguageTag: "en",
-				languageTags: [],
-				modules: [],
-				messageLintRuleLevels: {
-					[lintRule1.id]: "warning",
-					[lintRule2.id]: "warning",
-				},
-			},
-			rules: [lintRule1, lintRule2],
-			messages,
-		})
-
-		expect(fn).toHaveBeenCalledTimes(12)
-		expect(fn).toHaveBeenNthCalledWith(1, "r1", "before", "m1")
-		expect(fn).toHaveBeenNthCalledWith(2, "r2", "before", "m1")
-		expect(fn).toHaveBeenNthCalledWith(3, "r1", "before", "m2")
-		expect(fn).toHaveBeenNthCalledWith(4, "r2", "before", "m2")
-		expect(fn).toHaveBeenNthCalledWith(5, "r1", "before", "m3")
-		expect(fn).toHaveBeenNthCalledWith(6, "r2", "before", "m3")
-		expect(fn).toHaveBeenNthCalledWith(7, "r1", "after", "m1")
-		expect(fn).toHaveBeenNthCalledWith(8, "r2", "after", "m1")
-		expect(fn).toHaveBeenNthCalledWith(9, "r1", "after", "m2")
-		expect(fn).toHaveBeenNthCalledWith(10, "r2", "after", "m2")
-		expect(fn).toHaveBeenNthCalledWith(11, "r1", "after", "m3")
-		expect(fn).toHaveBeenNthCalledWith(12, "r2", "after", "m3")
-	})
-
-	test("it should not abort the linting process when errors occur", async () => {
-		lintRule1.run.mockImplementation(({ report }) => {
-			report({} as MessageLintReport)
-		})
-		lintRule2.run.mockImplementation(() => {
-			throw new Error("error")
-		})
-
-		const { data, errors } = await lintMessages({
-			settings: {
-				sourceLanguageTag: "en",
-				languageTags: [],
-				modules: [],
-				messageLintRuleLevels: {
-					[lintRule1.id]: "warning",
-					[lintRule2.id]: "warning",
-				},
-			},
-			messages,
-			rules: [lintRule1, lintRule2],
-		})
-
-		expect(data).toHaveLength(3)
-		expect(errors).toHaveLength(3)
-	})
-})