@inlang/sdk 0.36.3 → 2.0.0-beta.1

package/dist/resolve-modules/plugins/resolvePlugins.test.js

@@ -1,252 +0,0 @@
-/* eslint-disable @typescript-eslint/no-non-null-assertion */
-import { describe, expect, it } from "vitest";
-import { resolvePlugins } from "./resolvePlugins.js";
-import { PluginLoadMessagesFunctionAlreadyDefinedError, PluginSaveMessagesFunctionAlreadyDefinedError, PluginHasInvalidIdError, PluginReturnedInvalidCustomApiError, PluginsDoNotProvideLoadOrSaveMessagesError, } from "./errors.js";
-it("should return an error if a plugin uses an invalid id", async () => {
-    const mockPlugin = {
-        // @ts-expect-error - invalid id
-        id: "no-namespace",
-        description: { en: "My plugin description" },
-        displayName: { en: "My plugin" },
-        loadMessages: () => undefined,
-        saveMessages: () => undefined,
-    };
-    const resolved = await resolvePlugins({
-        plugins: [mockPlugin],
-        settings: {},
-        nodeishFs: {},
-    });
-    expect(resolved.errors[0]).toBeInstanceOf(PluginHasInvalidIdError);
-});
-it("should expose the project settings including the plugin settings", async () => {
-    const settings = {
-        sourceLanguageTag: "en",
-        languageTags: ["en", "de"],
-        modules: [],
-        "plugin.namespace.placeholder": {
-            myPluginSetting: "value",
-        },
-    };
-    const mockPlugin = {
-        id: "plugin.namespace.placeholder",
-        description: { en: "My plugin description" },
-        displayName: { en: "My plugin" },
-        saveMessages: async ({ settings }) => {
-            expect(settings).toStrictEqual(settings);
-        },
-        addCustomApi: ({ settings }) => {
-            expect(settings).toStrictEqual(settings);
-            return {};
-        },
-        loadMessages: async ({ settings }) => {
-            expect(settings).toStrictEqual(settings);
-            return [];
-        },
-    };
-    const resolved = await resolvePlugins({
-        plugins: [mockPlugin],
-        settings: settings,
-        nodeishFs: {},
-    });
-    await resolved.data.loadMessages({ settings, nodeishFs: {} });
-    await resolved.data.saveMessages({ settings, messages: [], nodeishFs: {} });
-});
-describe("loadMessages", () => {
-    it("should load messages from a local source", async () => {
-        const mockPlugin = {
-            id: "plugin.namespace.placeholder",
-            description: { en: "My plugin description" },
-            displayName: { en: "My plugin" },
-            loadMessages: async () => [
-                { id: "test", alias: {}, expressions: [], selectors: [], variants: [] },
-            ],
-        };
-        const resolved = await resolvePlugins({
-            plugins: [mockPlugin],
-            settings: {},
-            nodeishFs: {},
-        });
-        expect(await resolved.data.loadMessages({
-            settings: {},
-            nodeishFs: {},
-        })).toEqual([{ id: "test", alias: {}, expressions: [], selectors: [], variants: [] }]);
-    });
-    it("should collect an error if function is defined twice in multiple plugins", async () => {
-        const mockPlugin = {
-            id: "plugin.namepsace.loadMessagesFirst",
-            description: { en: "My plugin description" },
-            displayName: { en: "My plugin" },
-            loadMessages: async () => undefined,
-        };
-        const mockPlugin2 = {
-            id: "plugin.namepsace.loadMessagesSecond",
-            description: { en: "My plugin description" },
-            displayName: { en: "My plugin" },
-            loadMessages: async () => undefined,
-        };
-        const resolved = await resolvePlugins({
-            plugins: [mockPlugin, mockPlugin2],
-            nodeishFs: {},
-            settings: {},
-        });
-        expect(resolved.errors[0]).toBeInstanceOf(PluginLoadMessagesFunctionAlreadyDefinedError);
-    });
-    it("should return an error if no plugin defines loadMessages", async () => {
-        const mockPlugin = {
-            id: "plugin.namepsace.loadMessagesFirst",
-            description: { en: "My plugin description" },
-            displayName: { en: "My plugin" },
-            saveMessages: async () => undefined,
-        };
-        const resolved = await resolvePlugins({
-            plugins: [mockPlugin],
-            nodeishFs: {},
-            settings: {},
-        });
-        expect(resolved.errors).toHaveLength(1);
-        expect(resolved.errors[0]).toBeInstanceOf(PluginsDoNotProvideLoadOrSaveMessagesError);
-    });
-});
-describe("saveMessages", () => {
-    it("should save messages to a local source", async () => {
-        const mockPlugin = {
-            id: "plugin.namespace.placeholder",
-            description: { en: "My plugin description" },
-            displayName: { en: "My plugin" },
-            loadMessages: async () => undefined,
-            saveMessages: async () => undefined,
-        };
-        const resolved = await resolvePlugins({
-            plugins: [mockPlugin],
-            nodeishFs: {},
-            settings: {},
-        });
-        expect(resolved.errors).toHaveLength(0);
-    });
-    it("should collect an error if function is defined twice in multiple plugins", async () => {
-        const mockPlugin = {
-            id: "plugin.namepsace.saveMessages",
-            description: { en: "My plugin description" },
-            displayName: { en: "My plugin" },
-            saveMessages: async () => undefined,
-        };
-        const mockPlugin2 = {
-            id: "plugin.namepsace.saveMessages2",
-            description: { en: "My plugin description" },
-            displayName: { en: "My plugin" },
-            saveMessages: async () => undefined,
-        };
-        const resolved = await resolvePlugins({
-            plugins: [mockPlugin, mockPlugin2],
-            settings: {},
-            nodeishFs: {},
-        });
-        expect(resolved.errors[0]).toBeInstanceOf(PluginSaveMessagesFunctionAlreadyDefinedError);
-    });
-    it("should return an error if no plugin defines saveMessages", async () => {
-        const mockPlugin = {
-            id: "plugin.namepsace.loadMessagesFirst",
-            description: { en: "My plugin description" },
-            displayName: { en: "My plugin" },
-            loadMessages: async () => undefined,
-        };
-        const resolved = await resolvePlugins({
-            plugins: [mockPlugin],
-            nodeishFs: {},
-            settings: {},
-        });
-        expect(resolved.errors).toHaveLength(1);
-        expect(resolved.errors[0]).toBeInstanceOf(PluginsDoNotProvideLoadOrSaveMessagesError);
-    });
-});
-describe("addCustomApi", () => {
-    it("it should resolve app specific api", async () => {
-        const mockPlugin = {
-            id: "plugin.namespace.placeholder",
-            description: { en: "My plugin description" },
-            displayName: { en: "My plugin" },
-            addCustomApi: () => ({
-                "my-app": {
-                    messageReferenceMatcher: () => undefined,
-                },
-            }),
-        };
-        const resolved = await resolvePlugins({
-            plugins: [mockPlugin],
-            settings: {},
-            nodeishFs: {},
-        });
-        expect(resolved.data.customApi).toHaveProperty("my-app");
-    });
-    it("it should resolve multiple app specific apis", async () => {
-        const mockPlugin = {
-            id: "plugin.namespace.placeholder",
-            description: { en: "My plugin description" },
-            displayName: { en: "My plugin" },
-            addCustomApi: () => ({
-                "my-app-1": {
-                    functionOfMyApp1: () => undefined,
-                },
-                "my-app-2": {
-                    functionOfMyApp2: () => undefined,
-                },
-            }),
-        };
-        const mockPlugin2 = {
-            id: "plugin.namespace.placeholder2",
-            description: { en: "My plugin description" },
-            displayName: { en: "My plugin" },
-            addCustomApi: () => ({
-                "my-app-3": {
-                    functionOfMyApp3: () => undefined,
-                },
-            }),
-        };
-        const resolved = await resolvePlugins({
-            plugins: [mockPlugin, mockPlugin2],
-            settings: {},
-            nodeishFs: {},
-        });
-        expect(resolved.data.customApi).toHaveProperty("my-app-1");
-        expect(resolved.data.customApi).toHaveProperty("my-app-2");
-        expect(resolved.data.customApi).toHaveProperty("my-app-3");
-    });
-    it("it should throw an error if return value is not an object", async () => {
-        const mockPlugin = {
-            id: "plugin.namespace.placeholder",
-            description: { en: "My plugin description" },
-            displayName: { en: "My plugin" },
-            // @ts-expect-error - invalid return type
-            addCustomApi: () => undefined,
-        };
-        const resolved = await resolvePlugins({
-            plugins: [mockPlugin],
-            settings: {},
-            nodeishFs: {},
-        });
-        expect(resolved.errors[0]).toBeInstanceOf(PluginReturnedInvalidCustomApiError);
-    });
-    it("it should throw an error if the passed options are not defined inside customApi", async () => {
-        const mockPlugin = {
-            id: "plugin.namepsace.placeholder",
-            description: { en: "My plugin description" },
-            displayName: { en: "My plugin" },
-            addCustomApi: () => ({
-                "app.inlang.placeholder": {
-                    messageReferenceMatcher: () => {
-                        return { hello: "world" };
-                    },
-                },
-            }),
-        };
-        const resolved = await resolvePlugins({
-            plugins: [mockPlugin],
-            settings: {},
-            nodeishFs: {},
-        });
-        expect(resolved.data.customApi).toHaveProperty("app.inlang.placeholder");
-        expect((resolved.data.customApi?.["app.inlang.placeholder"]).messageReferenceMatcher()).toEqual({
-            hello: "world",
-        });
-    });
-});

package/dist/resolve-modules/plugins/types.d.ts

@@ -1,57 +0,0 @@
-import type { NodeishFilesystem } from "@lix-js/fs";
-import type { PluginReturnedInvalidCustomApiError, PluginLoadMessagesFunctionAlreadyDefinedError, PluginSaveMessagesFunctionAlreadyDefinedError, PluginHasInvalidIdError, PluginHasInvalidSchemaError, PluginsDoNotProvideLoadOrSaveMessagesError } from "./errors.js";
-import type { Message } from "@inlang/message";
-import type { CustomApiInlangIdeExtension, Plugin } from "@inlang/plugin";
-import type { ProjectSettings } from "@inlang/project-settings";
-/**
- * The filesystem is a subset of project lisa's nodeish filesystem.
- *
- * - only uses minimally required functions to decrease the API footprint on the ecosystem.
- */
-export type NodeishFilesystemSubset = Pick<NodeishFilesystem, "readFile" | "readdir" | "mkdir" | "writeFile" | "watch">;
-/**
- * Function that resolves (imports and initializes) the plugins.
- */
-export type ResolvePluginsFunction = (args: {
-    plugins: Array<Plugin>;
-    settings: ProjectSettings;
-    nodeishFs: NodeishFilesystemSubset;
-}) => Promise<{
-    data: ResolvedPluginApi;
-    errors: Array<PluginReturnedInvalidCustomApiError | PluginLoadMessagesFunctionAlreadyDefinedError | PluginSaveMessagesFunctionAlreadyDefinedError | PluginHasInvalidIdError | PluginHasInvalidSchemaError | PluginsDoNotProvideLoadOrSaveMessagesError>;
-}>;
-/**
- * The API after resolving the plugins.
- */
-export type ResolvedPluginApi = {
-    loadMessages: (args: {
-        settings: ProjectSettings;
-        nodeishFs: NodeishFilesystemSubset;
-    }) => Promise<Message[]> | Message[];
-    saveMessages: (args: {
-        settings: ProjectSettings;
-        messages: Message[];
-        nodeishFs: NodeishFilesystemSubset;
-    }) => Promise<void> | void;
-    /**
-     * App specific APIs.
-     *
-     * @example
-     *  // define
-     *  customApi: ({ settings }) => ({
-     * 	 "app.inlang.ide-extension": {
-     * 	   messageReferenceMatcher: () => {
-     * 		 // use settings
-     * 		 settings.pathPattern
-     * 		return
-     * 	   }
-     * 	 }
-     *  })
-     *  // use
-     *  customApi['app.inlang.ide-extension'].messageReferenceMatcher()
-     */
-    customApi: Record<`app.${string}.${string}` | `library.${string}.${string}`, unknown> & {
-        "app.inlang.ideExtension"?: CustomApiInlangIdeExtension;
-    };
-};
-//# sourceMappingURL=types.d.ts.map

package/dist/resolve-modules/plugins/types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/resolve-modules/plugins/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAA;AACnD,OAAO,KAAK,EACX,mCAAmC,EACnC,6CAA6C,EAC7C,6CAA6C,EAC7C,uBAAuB,EACvB,2BAA2B,EAC3B,0CAA0C,EAC1C,MAAM,aAAa,CAAA;AACpB,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAA;AAC9C,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAA;AACzE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAA;AAE/D;;;;GAIG;AACH,MAAM,MAAM,uBAAuB,GAAG,IAAI,CACzC,iBAAiB,EACjB,UAAU,GAAG,SAAS,GAAG,OAAO,GAAG,WAAW,GAAG,OAAO,CACxD,CAAA;AAED;;GAEG;AACH,MAAM,MAAM,sBAAsB,GAAG,CAAC,IAAI,EAAE;IAC3C,OAAO,EAAE,KAAK,CAAC,MAAM,CAAC,CAAA;IACtB,QAAQ,EAAE,eAAe,CAAA;IACzB,SAAS,EAAE,uBAAuB,CAAA;CAClC,KAAK,OAAO,CAAC;IACb,IAAI,EAAE,iBAAiB,CAAA;IACvB,MAAM,EAAE,KAAK,CACV,mCAAmC,GACnC,6CAA6C,GAC7C,6CAA6C,GAC7C,uBAAuB,GACvB,2BAA2B,GAC3B,0CAA0C,CAC5C,CAAA;CACD,CAAC,CAAA;AAEF;;GAEG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC/B,YAAY,EAAE,CAAC,IAAI,EAAE;QACpB,QAAQ,EAAE,eAAe,CAAA;QACzB,SAAS,EAAE,uBAAuB,CAAA;KAClC,KAAK,OAAO,CAAC,OAAO,EAAE,CAAC,GAAG,OAAO,EAAE,CAAA;IACpC,YAAY,EAAE,CAAC,IAAI,EAAE;QACpB,QAAQ,EAAE,eAAe,CAAA;QACzB,QAAQ,EAAE,OAAO,EAAE,CAAA;QACnB,SAAS,EAAE,uBAAuB,CAAA;KAClC,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAA;IAC1B;;;;;;;;;;;;;;;;OAgBG;IACH,SAAS,EAAE,MAAM,CAAC,OAAO,MAAM,IAAI,MAAM,EAAE,GAAG,WAAW,MAAM,IAAI,MAAM,EAAE,EAAE,OAAO,CAAC,GAAG;QACvF,yBAAyB,CAAC,EAAE,2BAA2B,CAAA;KACvD,CAAA;CACD,CAAA"}

package/dist/resolve-modules/plugins/types.js

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

package/dist/resolve-modules/plugins/types.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=types.test.d.ts.map

package/dist/resolve-modules/plugins/types.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.test.d.ts","sourceRoot":"","sources":["../../../src/resolve-modules/plugins/types.test.ts"],"names":[],"mappings":""}

package/dist/resolve-modules/plugins/types.test.js

@@ -1,45 +0,0 @@
-import { ProjectSettings } from "@inlang/project-settings";
-import { Value } from "@sinclair/typebox/value";
-import { describe, test, expect } from "vitest";
-import { expectType } from "tsd";
-import { Plugin } from "@inlang/plugin";
-describe("Plugin", () => {
-    test("meta.id should enforce plugin.namespace.* patterns", () => {
-        expectType("");
-        const mockPlugin = {
-            id: "plugin.namespace.placeholder",
-            displayName: { en: "" },
-            description: { en: "" },
-        };
-        const passCases = ["plugin.namespace.helloWorld", "plugin.namespace.i18n"];
-        const failCases = [
-            "namespace.hello_World",
-            "plugin.namespace-HelloWorld",
-            "lintRule.namespace.coolPlugin",
-        ];
-        for (const pass of passCases) {
-            mockPlugin.id = pass;
-            // @ts-ignore - type mismatch error. fix after refactor
-            expect(Value.Check(Plugin, mockPlugin)).toBe(true);
-        }
-        for (const fail of failCases) {
-            mockPlugin.id = fail;
-            // @ts-ignore - type mismatch error. fix after refactor
-            expect(Value.Check(Plugin, mockPlugin)).toBe(false);
-        }
-    });
-    test("meta.id should be a valid inlang.config.setting key", () => {
-        const settings = {
-            sourceLanguageTag: "en",
-            languageTags: ["en", "de"],
-            modules: [],
-        };
-        const cases = ["plugin.namespace.helloWorld", "plugin.namespace.i18n"];
-        for (const _case of cases) {
-            const mergedSettings = { ...settings, [_case]: {} };
-            expect(Value.Check(ProjectSettings, mergedSettings)).toBe(true);
-            // @ts-ignore - type mismatch error. fix after refactor
-            expect(Value.Check(Plugin["properties"]["id"], _case)).toBe(true);
-        }
-    });
-});

package/dist/resolve-modules/resolveModules.d.ts

@@ -1,3 +0,0 @@
-import type { ResolveModuleFunction } from "./types.js";
-export declare const resolveModules: ResolveModuleFunction;
-//# sourceMappingURL=resolveModules.d.ts.map

package/dist/resolve-modules/resolveModules.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"resolveModules.d.ts","sourceRoot":"","sources":["../../src/resolve-modules/resolveModules.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAA;AAoBvD,eAAO,MAAM,cAAc,EAAE,qBA4F5B,CAAA"}

package/dist/resolve-modules/resolveModules.js

@@ -1,80 +0,0 @@
-import { InlangModule } from "@inlang/module";
-import { ModuleError, ModuleImportError, ModuleHasNoExportsError, ModuleExportIsInvalidError, ModuleSettingsAreInvalidError, } from "./errors.js";
-import { tryCatch } from "@inlang/result";
-import { resolveMessageLintRules } from "./message-lint-rules/resolveMessageLintRules.js";
-import { createImport } from "./import.js";
-import { resolvePlugins } from "./plugins/resolvePlugins.js";
-import { TypeCompiler } from "@sinclair/typebox/compiler";
-import { validatedModuleSettings } from "./validatedModuleSettings.js";
-const ModuleCompiler = TypeCompiler.Compile(InlangModule);
-export const resolveModules = async (args) => {
-    const _import = args._import ?? createImport(args.projectPath, args.nodeishFs);
-    const allPlugins = [];
-    const allMessageLintRules = [];
-    const meta = [];
-    const moduleErrors = [];
-    async function resolveModule(module) {
-        const importedModule = await tryCatch(() => _import(module));
-        // -- FAILED TO IMPORT --
-        if (importedModule.error) {
-            moduleErrors.push(new ModuleImportError({
-                module: module,
-                cause: importedModule.error,
-            }));
-            return;
-        }
-        // -- MODULE DOES NOT EXPORT ANYTHING --
-        if (importedModule.data?.default === undefined) {
-            moduleErrors.push(new ModuleHasNoExportsError({
-                module: module,
-            }));
-            return;
-        }
-        // -- CHECK IF MODULE IS SYNTACTIALLY VALID
-        const isValidModule = ModuleCompiler.Check(importedModule.data);
-        if (isValidModule === false) {
-            const errors = [...ModuleCompiler.Errors(importedModule.data)];
-            moduleErrors.push(new ModuleExportIsInvalidError({
-                module: module,
-                errors,
-            }));
-            return;
-        }
-        // -- VALIDATE MODULE SETTINGS
-        const result = validatedModuleSettings({
-            settingsSchema: importedModule.data.default.settingsSchema,
-            moduleSettings: args.settings[importedModule.data.default.id],
-        });
-        if (result !== "isValid") {
-            moduleErrors.push(new ModuleSettingsAreInvalidError({ module: module, errors: result }));
-            return;
-        }
-        meta.push({
-            module: module,
-            id: importedModule.data.default.id,
-        });
-        if (importedModule.data.default.id.startsWith("plugin.")) {
-            allPlugins.push(importedModule.data.default);
-        }
-        else if (importedModule.data.default.id.startsWith("messageLintRule.")) {
-            allMessageLintRules.push(importedModule.data.default);
-        }
-        else {
-            moduleErrors.push(new ModuleError(`Unimplemented module type ${importedModule.data.default.id}.The module has not been installed.`, { module: module }));
-        }
-    }
-    await Promise.all(args.settings.modules.map(resolveModule));
-    const resolvedPlugins = await resolvePlugins({
-        plugins: allPlugins,
-        settings: args.settings,
-        nodeishFs: args.nodeishFs,
-    });
-    const resolvedLintRules = resolveMessageLintRules({ messageLintRules: allMessageLintRules });
-    return {
-        meta,
-        messageLintRules: allMessageLintRules,
-        plugins: allPlugins,
-        resolvedPluginApi: resolvedPlugins.data,
-        errors: [...moduleErrors, ...resolvedLintRules.errors, ...resolvedPlugins.errors],
-    };
-};

package/dist/resolve-modules/resolveModules.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=resolveModules.test.d.ts.map

package/dist/resolve-modules/resolveModules.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"resolveModules.test.d.ts","sourceRoot":"","sources":["../../src/resolve-modules/resolveModules.test.ts"],"names":[],"mappings":""}

package/dist/resolve-modules/resolveModules.test.js

@@ -1,185 +0,0 @@
-import { expect, it } from "vitest";
-import { ModuleError, ModuleExportIsInvalidError, ModuleHasNoExportsError, ModuleImportError, ModuleSettingsAreInvalidError, } from "./errors.js";
-import { resolveModules } from "./resolveModules.js";
-import { Type } from "@sinclair/typebox";
-it("should return an error if a plugin cannot be imported", async () => {
-    const settings = {
-        sourceLanguageTag: "en",
-        languageTags: ["de", "en"],
-        modules: ["https://myplugin.com/index.js"],
-    };
-    const resolved = await resolveModules({
-        projectPath: "/project.inlang",
-        settings,
-        nodeishFs: {},
-        _import: () => {
-            throw new ModuleImportError({
-                module: settings.modules[0],
-                cause: new Error("Could not import"),
-            });
-        },
-    });
-    expect(resolved.errors[0]).toBeInstanceOf(ModuleImportError);
-});
-it("should resolve plugins and message lint rules successfully", async () => {
-    // Define mock data
-    const mockPlugin = {
-        id: "plugin.namespace.mock",
-        description: { en: "Mock plugin description" },
-        displayName: { en: "Mock Plugin" },
-        loadMessages: () => undefined,
-        saveMessages: () => undefined,
-        addCustomApi: () => ({
-            "app.inlang.ideExtension": {
-                messageReferenceMatcher: () => undefined,
-            },
-        }),
-    };
-    const mockMessageLintRule = {
-        id: "messageLintRule.namespace.mock",
-        description: { en: "Mock lint rule description" },
-        displayName: { en: "Mock Lint Rule" },
-        run: () => undefined,
-    };
-    const settings = {
-        sourceLanguageTag: "en",
-        languageTags: ["de", "en"],
-        modules: ["lint-rule.js", "plugin.js"],
-    };
-    const _import = async (name) => {
-        if (name === "lint-rule.js") {
-            return {
-                default: mockMessageLintRule,
-            };
-        }
-        else {
-            return {
-                default: mockPlugin,
-            };
-        }
-    };
-    // Call the function
-    const resolved = await resolveModules({
-        projectPath: "/project.inlang",
-        settings,
-        _import,
-        nodeishFs: {},
-    });
-    // Assert results
-    expect(resolved.errors).toHaveLength(0);
-    // Check for the meta data of the plugin
-    expect(resolved.plugins.some((module) => module.id === mockPlugin.id)).toBeDefined();
-    // Check for the app specific api
-    expect(resolved.resolvedPluginApi["customApi"]?.["app.inlang.ideExtension"]).toBeDefined();
-    // Check for the lint rule
-    expect(resolved.messageLintRules[0]?.id).toBe(mockMessageLintRule.id);
-});
-it("should return an error if a module cannot be imported", async () => {
-    const settings = {
-        sourceLanguageTag: "en",
-        languageTags: ["de", "en"],
-        modules: ["https://myplugin.com/index.js"],
-    };
-    const _import = async () => {
-        throw new ModuleImportError({
-            module: settings.modules[0],
-            cause: new Error(),
-        });
-    };
-    // Call the function
-    const resolved = await resolveModules({
-        projectPath: "/project.inlang",
-        settings,
-        _import,
-        nodeishFs: {},
-    });
-    // Assert results
-    expect(resolved.errors[0]).toBeInstanceOf(ModuleImportError);
-});
-it("should return an error if a module does not export anything", async () => {
-    const settings = {
-        sourceLanguageTag: "en",
-        languageTags: ["de", "en"],
-        modules: ["https://myplugin.com/index.js"],
-    };
-    const _import = async () => ({});
-    // Call the function
-    const resolved = await resolveModules({
-        projectPath: "/project.inlang",
-        settings,
-        _import,
-        nodeishFs: {},
-    });
-    // Assert results
-    expect(resolved.errors[0]).toBeInstanceOf(ModuleHasNoExportsError);
-});
-it("should return an error if a module exports an invalid plugin or lint rule", async () => {
-    const settings = {
-        sourceLanguageTag: "en",
-        languageTags: ["de", "en"],
-        modules: ["https://myplugin.com/index.js"],
-    };
-    const _import = async () => ({
-        // @ts-expect-error - invalid meta of a plugin
-        default: {
-            id: "plugin.namespace.mock",
-            description: { en: "Mock plugin description" },
-        },
-    });
-    const resolved = await resolveModules({
-        projectPath: "/project.inlang",
-        settings,
-        _import,
-        nodeishFs: {},
-    });
-    expect(resolved.errors[0]).toBeInstanceOf(ModuleExportIsInvalidError);
-});
-it("should handle other unhandled errors during plugin resolution", async () => {
-    const errorMessage = "Unhandled error during plugin resolution";
-    const settings = {
-        sourceLanguageTag: "en",
-        languageTags: ["de", "en"],
-        modules: ["https://myplugin.com/index.js"],
-    };
-    const _import = async () => {
-        throw new Error(errorMessage);
-    };
-    // Call the function
-    const resolved = await resolveModules({
-        projectPath: "/project.inlang",
-        settings,
-        _import,
-        nodeishFs: {},
-    });
-    // Assert results
-    expect(resolved.errors[0]).toBeInstanceOf(ModuleError);
-});
-it("should return an error if a moduleSettings are invalid", async () => {
-    const settings = {
-        sourceLanguageTag: "en",
-        languageTags: ["de", "en"],
-        modules: ["plugin.js"],
-        "plugin.namespace.mock": {
-            ignore: ["invalid"],
-        },
-    };
-    const _import = async () => ({
-        default: {
-            id: "plugin.namespace.mock",
-            description: { en: "Mock plugin description" },
-            displayName: { en: "Mock Plugin" },
-            settingsSchema: Type.Object({
-                ignore: Type.String(),
-            }),
-        },
-    });
-    // Call the function
-    const resolved = await resolveModules({
-        projectPath: "/project.inlang",
-        settings,
-        _import,
-        nodeishFs: {},
-    });
-    // Assert results
-    expect(resolved.errors[0]).toBeInstanceOf(ModuleSettingsAreInvalidError);
-});