@inlang/sdk 0.1.0

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

@@ -0,0 +1,44 @@
+class PluginError extends Error {
+    plugin;
+    constructor(message, options) {
+        super(message);
+        this.name = "PluginError";
+        this.plugin = options.plugin;
+    }
+}
+export class PluginHasInvalidIdError extends PluginError {
+    constructor(message, options) {
+        super(message, options);
+        this.name = "PluginHasInvalidIdError";
+    }
+}
+export class PluginUsesReservedNamespaceError extends PluginError {
+    constructor(message, options) {
+        super(message, options);
+        this.name = "PluginUsesReservedNamespaceError";
+    }
+}
+export class PluginHasInvalidSchemaError extends PluginError {
+    constructor(message, options) {
+        super(message, options);
+        this.name = "PluginHasInvalidSchemaError";
+    }
+}
+export class PluginLoadMessagesFunctionAlreadyDefinedError extends PluginError {
+    constructor(message, options) {
+        super(message, options);
+        this.name = "PluginLoadMessagesFunctionAlreadyDefinedError";
+    }
+}
+export class PluginSaveMessagesFunctionAlreadyDefinedError extends PluginError {
+    constructor(message, options) {
+        super(message, options);
+        this.name = "PluginSaveMessagesFunctionAlreadyDefinedError";
+    }
+}
+export class PluginReturnedInvalidCustomApiError extends PluginError {
+    constructor(message, options) {
+        super(message, options);
+        this.name = "PluginReturnedInvalidCustomApiError";
+    }
+}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"resolvePlugins.d.ts","sourceRoot":"","sources":["../../../src/resolve-modules/plugins/resolvePlugins.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAA;AAsBxD,eAAO,MAAM,cAAc,EAAE,sBAkJ5B,CAAA"}

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

@@ -0,0 +1,108 @@
+import { Plugin } from "@inlang/plugin";
+import { PluginReturnedInvalidCustomApiError, PluginLoadMessagesFunctionAlreadyDefinedError, PluginSaveMessagesFunctionAlreadyDefinedError, PluginHasInvalidIdError, PluginHasInvalidSchemaError, PluginUsesReservedNamespaceError, } from "./errors.js";
+import { deepmerge } from "deepmerge-ts";
+import { TypeCompiler } from "@sinclair/typebox/compiler";
+import { tryCatch } from "@inlang/result";
+const whitelistedPlugins = [
+    "plugin.inlang.json",
+    "plugin.inlang.i18next",
+    "plugin.inlang.paraglideJs",
+];
+// @ts-ignore - type mismatch error
+const PluginCompiler = TypeCompiler.Compile(Plugin);
+export const resolvePlugins = async (args) => {
+    const result = {
+        data: {
+            loadMessages: undefined,
+            saveMessages: undefined,
+            detectedLanguageTags: [],
+            customApi: {},
+        },
+        errors: [],
+    };
+    for (const plugin of args.plugins) {
+        const errors = [...PluginCompiler.Errors(plugin)];
+        /**
+         * -------------- RESOLVE PLUGIN --------------
+         */
+        // -- INVALID ID in META --
+        const hasInvalidId = errors.some((error) => error.path === "/meta/id");
+        if (hasInvalidId) {
+            result.errors.push(new PluginHasInvalidIdError(`Plugin ${plugin.meta.id} has an invalid id "${plugin.meta.id}". It must be kebap-case and contain a namespace like project.my-plugin.`, { plugin: plugin.meta.id }));
+        }
+        // -- USES RESERVED NAMESPACE --
+        if (plugin.meta.id.includes("inlang") && !whitelistedPlugins.includes(plugin.meta.id)) {
+            result.errors.push(new PluginUsesReservedNamespaceError(`Plugin ${plugin.meta.id} uses reserved namespace 'inlang'.`, {
+                plugin: plugin.meta.id,
+            }));
+        }
+        // -- USES INVALID SCHEMA --
+        if (errors.length > 0) {
+            result.errors.push(new PluginHasInvalidSchemaError(`Plugin ${plugin.meta.id} uses an invalid schema. Please check the documentation for the correct Plugin type.`, {
+                plugin: plugin.meta.id,
+                cause: errors,
+            }));
+        }
+        // -- ALREADY DEFINED LOADMESSAGES / SAVEMESSAGES / DETECTEDLANGUAGETAGS --
+        if (typeof plugin.loadMessages === "function" && result.data.loadMessages !== undefined) {
+            result.errors.push(new PluginLoadMessagesFunctionAlreadyDefinedError(`Plugin ${plugin.meta.id} defines the loadMessages function, but it was already defined by another plugin.`, { plugin: plugin.meta.id }));
+        }
+        if (typeof plugin.saveMessages === "function" && result.data.saveMessages !== undefined) {
+            result.errors.push(new PluginSaveMessagesFunctionAlreadyDefinedError(`Plugin ${plugin.meta.id} defines the saveMessages function, but it was already defined by another plugin.`, { plugin: plugin.meta.id }));
+        }
+        // --- ADD APP SPECIFIC API ---
+        if (typeof plugin.addCustomApi === "function") {
+            // TODO: why do we call this function 2 times (here for validation and later for retrieving the actual value)?
+            const { data: customApi, error } = tryCatch(() => plugin.addCustomApi({
+                settings: args.settings?.[plugin.meta.id] ?? {},
+            }));
+            if (error) {
+                // @ts-ignore
+                delete error.stack;
+                result.errors.push(error); // TODO: add correct error type
+            }
+            if (typeof customApi !== "object") {
+                result.errors.push(new PluginReturnedInvalidCustomApiError(`Plugin ${plugin.meta.id} defines the addCustomApi function, but it does not return an object.`, { plugin: plugin.meta.id, cause: error }));
+            }
+        }
+        // -- CONTINUE IF ERRORS --
+        if (result.errors.length > 0) {
+            continue;
+        }
+        /**
+         * -------------- BEGIN ADDING TO RESULT --------------
+         */
+        if (typeof plugin.loadMessages === "function") {
+            result.data.loadMessages = (_args) => plugin.loadMessages({
+                ..._args,
+                settings: args.settings?.[plugin.meta.id] ?? {},
+                nodeishFs: args.nodeishFs,
+            });
+        }
+        if (typeof plugin.saveMessages === "function") {
+            result.data.saveMessages = (_args) => plugin.saveMessages({
+                ..._args,
+                settings: args.settings?.[plugin.meta.id] ?? {},
+                nodeishFs: args.nodeishFs,
+            });
+        }
+        if (typeof plugin.detectedLanguageTags === "function") {
+            const detectedLangugeTags = await plugin.detectedLanguageTags({
+                settings: args.settings?.[plugin.meta.id] ?? {},
+                nodeishFs: args.nodeishFs,
+            });
+            result.data.detectedLanguageTags = [
+                ...new Set([...result.data.detectedLanguageTags, ...detectedLangugeTags]),
+            ];
+        }
+        if (typeof plugin.addCustomApi === "function") {
+            const { data: customApi } = tryCatch(() => plugin.addCustomApi({
+                settings: args.settings?.[plugin.meta.id] ?? {},
+            }));
+            if (customApi) {
+                result.data.customApi = deepmerge(result.data.customApi, customApi);
+            }
+        }
+    }
+    return result;
+};

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

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

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

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

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

@@ -0,0 +1,289 @@
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+import { describe, expect, it } from "vitest";
+import { resolvePlugins } from "./resolvePlugins.js";
+import { PluginLoadMessagesFunctionAlreadyDefinedError, PluginSaveMessagesFunctionAlreadyDefinedError, PluginHasInvalidIdError, PluginUsesReservedNamespaceError, PluginReturnedInvalidCustomApiError, PluginHasInvalidSchemaError, } from "./errors.js";
+describe("generally", () => {
+    it("should return an error if a plugin uses an invalid id", async () => {
+        const mockPlugin = {
+            meta: {
+                // @ts-expect-error - invalid id
+                id: "no-namespace",
+                description: { en: "My plugin description" },
+                displayName: { en: "My plugin" },
+            },
+            loadMessages: () => undefined,
+            saveMessages: () => undefined,
+            addCustomApi() {
+                return {};
+            },
+        };
+        const resolved = await resolvePlugins({
+            plugins: [mockPlugin],
+            settings: {},
+            nodeishFs: {},
+        });
+        expect(resolved.errors[0]).toBeInstanceOf(PluginHasInvalidIdError);
+    });
+    it("should return an error if a plugin uses APIs that are not available", async () => {
+        const mockPlugin = {
+            meta: {
+                id: "plugin.namespace.undefinedApi",
+                description: { en: "My plugin description" },
+                displayName: { en: "My plugin" },
+            },
+            // @ts-expect-error the key is not available in type
+            nonExistentKey: {
+                nonexistentOptions: "value",
+            },
+            loadMessages: () => undefined,
+            saveMessages: () => undefined,
+        };
+        const resolved = await resolvePlugins({
+            plugins: [mockPlugin],
+            settings: {},
+            nodeishFs: {},
+        });
+        expect(resolved.errors.length).toBe(1);
+        expect(resolved.errors[0]).toBeInstanceOf(PluginHasInvalidSchemaError);
+    });
+    it("should not initialize a plugin that uses the 'inlang' namespace except for inlang whitelisted plugins", async () => {
+        const mockPlugin = {
+            meta: {
+                id: "plugin.inlang.notWhitelisted",
+                description: { en: "My plugin description" },
+                displayName: { en: "My plugin" },
+            },
+            loadMessages: () => undefined,
+        };
+        const resolved = await resolvePlugins({
+            plugins: [mockPlugin],
+            settings: {},
+            nodeishFs: {},
+        });
+        expect(resolved.errors.length).toBe(1);
+        expect(resolved.errors[0]).toBeInstanceOf(PluginUsesReservedNamespaceError);
+    });
+});
+describe("loadMessages", () => {
+    it("should load messages from a local source", async () => {
+        const mockPlugin = {
+            meta: {
+                id: "plugin.namespace.placeholder",
+                description: { en: "My plugin description" },
+                displayName: { en: "My plugin" },
+            },
+            loadMessages: async () => [{ id: "test", expressions: [], selectors: [], variants: [] }],
+        };
+        const resolved = await resolvePlugins({
+            plugins: [mockPlugin],
+            settings: {},
+            nodeishFs: {},
+        });
+        expect(await resolved.data.loadMessages({
+            languageTags: ["en"],
+            sourceLanguageTag: "en",
+        })).toEqual([{ id: "test", expressions: [], selectors: [], variants: [] }]);
+    });
+    it("should collect an error if function is defined twice in multiple plugins", async () => {
+        const mockPlugin = {
+            meta: {
+                id: "plugin.namepsace.loadMessagesFirst",
+                description: { en: "My plugin description" },
+                displayName: { en: "My plugin" },
+            },
+            loadMessages: async () => undefined,
+        };
+        const mockPlugin2 = {
+            meta: {
+                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).toHaveLength(1);
+        expect(resolved.errors[0]).toBeInstanceOf(PluginLoadMessagesFunctionAlreadyDefinedError);
+    });
+});
+describe("saveMessages", () => {
+    it("should save messages to a local source", async () => {
+        const mockPlugin = {
+            meta: {
+                id: "plugin.namespace.placeholder",
+                description: { en: "My plugin description" },
+                displayName: { en: "My plugin" },
+            },
+            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 = {
+            meta: {
+                id: "plugin.namepsace.saveMessages",
+                description: { en: "My plugin description" },
+                displayName: { en: "My plugin" },
+            },
+            saveMessages: async () => undefined,
+        };
+        const mockPlugin2 = {
+            meta: {
+                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).toHaveLength(1);
+        expect(resolved.errors[0]).toBeInstanceOf(PluginSaveMessagesFunctionAlreadyDefinedError);
+    });
+});
+describe("detectedLanguageTags", () => {
+    it("should merge language tags from plugins", async () => {
+        const mockPlugin = {
+            meta: {
+                id: "plugin.namepsace.detectedLanguageTags",
+                description: { en: "My plugin description" },
+                displayName: { en: "My plugin" },
+            },
+            detectedLanguageTags: async () => ["de", "en"],
+            addCustomApi: () => {
+                return {};
+            },
+        };
+        const mockPlugin2 = {
+            meta: {
+                id: "plugin.namepsace.detectedLanguageTags2",
+                description: { en: "My plugin description" },
+                displayName: { en: "My plugin" },
+            },
+            addCustomApi: () => {
+                return {};
+            },
+            detectedLanguageTags: async () => ["de", "fr"],
+        };
+        const resolved = await resolvePlugins({
+            plugins: [mockPlugin, mockPlugin2],
+            settings: {},
+            nodeishFs: {},
+        });
+        expect(resolved.data.detectedLanguageTags).toEqual(["de", "en", "fr"]);
+    });
+});
+describe("addCustomApi", () => {
+    it("it should resolve app specific api", async () => {
+        const mockPlugin = {
+            meta: {
+                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 = {
+            meta: {
+                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 = {
+            meta: {
+                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 = {
+            meta: {
+                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).toHaveLength(1);
+        expect(resolved.errors[0]).toBeInstanceOf(PluginReturnedInvalidCustomApiError);
+    });
+    it("it should throw an error if the passed options are not defined inside customApi", async () => {
+        const mockPlugin = {
+            meta: {
+                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

@@ -0,0 +1,60 @@
+import type { LanguageTag } from "@inlang/language-tag";
+import type { NodeishFilesystem as LisaNodeishFilesystem } from "@lix-js/fs";
+import type { PluginReturnedInvalidCustomApiError, PluginLoadMessagesFunctionAlreadyDefinedError, PluginSaveMessagesFunctionAlreadyDefinedError, PluginHasInvalidIdError, PluginHasInvalidSchemaError, PluginUsesReservedNamespaceError } from "./errors.js";
+import type { Message } from "@inlang/message";
+import type { JSONObject } from "@inlang/json-types";
+import type { CustomApiInlangIdeExtension, Plugin } from "@inlang/plugin";
+/**
+ * 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<LisaNodeishFilesystem, "readFile" | "readdir" | "mkdir" | "writeFile">;
+/**
+ * Function that resolves (imports and initializes) the plugins.
+ */
+export type ResolvePluginsFunction = (args: {
+    plugins: Array<Plugin>;
+    settings: Record<Plugin["meta"]["id"], JSONObject>;
+    nodeishFs: NodeishFilesystemSubset;
+}) => Promise<{
+    data: ResolvedPluginApi;
+    errors: Array<PluginReturnedInvalidCustomApiError | PluginLoadMessagesFunctionAlreadyDefinedError | PluginSaveMessagesFunctionAlreadyDefinedError | PluginHasInvalidIdError | PluginHasInvalidSchemaError | PluginUsesReservedNamespaceError>;
+}>;
+/**
+ * The API after resolving the plugins.
+ */
+export type ResolvedPluginApi = {
+    loadMessages: (args: {
+        languageTags: LanguageTag[];
+        sourceLanguageTag: LanguageTag;
+    }) => Promise<Message[]> | Message[];
+    saveMessages: (args: {
+        messages: Message[];
+    }) => Promise<void> | void;
+    /**
+     * Detect language tags in the project provided plugins.
+     */
+    detectedLanguageTags: LanguageTag[];
+    /**
+     * 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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/resolve-modules/plugins/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAA;AACvD,OAAO,KAAK,EAAE,iBAAiB,IAAI,qBAAqB,EAAE,MAAM,YAAY,CAAA;AAC5E,OAAO,KAAK,EACX,mCAAmC,EACnC,6CAA6C,EAC7C,6CAA6C,EAC7C,uBAAuB,EACvB,2BAA2B,EAC3B,gCAAgC,EAChC,MAAM,aAAa,CAAA;AACpB,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAA;AAC9C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAA;AACpD,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAA;AAEzE;;;;GAIG;AACH,MAAM,MAAM,uBAAuB,GAAG,IAAI,CACzC,qBAAqB,EACrB,UAAU,GAAG,SAAS,GAAG,OAAO,GAAG,WAAW,CAC9C,CAAA;AAED;;GAEG;AACH,MAAM,MAAM,sBAAsB,GAAG,CAAC,IAAI,EAAE;IAC3C,OAAO,EAAE,KAAK,CAAC,MAAM,CAAC,CAAA;IACtB,QAAQ,EAAE,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,EAAE,UAAU,CAAC,CAAA;IAClD,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,gCAAgC,CAClC,CAAA;CACD,CAAC,CAAA;AAEF;;GAEG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC/B,YAAY,EAAE,CAAC,IAAI,EAAE;QACpB,YAAY,EAAE,WAAW,EAAE,CAAA;QAC3B,iBAAiB,EAAE,WAAW,CAAA;KAC9B,KAAK,OAAO,CAAC,OAAO,EAAE,CAAC,GAAG,OAAO,EAAE,CAAA;IACpC,YAAY,EAAE,CAAC,IAAI,EAAE;QAAE,QAAQ,EAAE,OAAO,EAAE,CAAA;KAAE,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAA;IACrE;;OAEG;IACH,oBAAoB,EAAE,WAAW,EAAE,CAAA;IACnC;;;;;;;;;;;;;;;;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

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

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

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

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,49 @@
+import { ProjectConfig } from "@inlang/project-config";
+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 = {
+            meta: {
+                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.meta.id = pass;
+            // @ts-ignore - type mismatch error. fix after refactor
+            expect(Value.Check(Plugin, mockPlugin)).toBe(true);
+        }
+        for (const fail of failCases) {
+            mockPlugin.meta.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 mockConfig = {
+            sourceLanguageTag: "en",
+            languageTags: ["en", "de"],
+            modules: [],
+            settings: {},
+        };
+        const cases = ["plugin.namespace.helloWorld", "plugin.namespace.i18n"];
+        for (const _case of cases) {
+            const config = { ...mockConfig, settings: { [_case]: {} } };
+            // @ts-ignore - type mismatch error. fix after refactor
+            expect(Value.Check(ProjectConfig, config)).toBe(true);
+            // @ts-ignore - type mismatch error. fix after refactor
+            expect(Value.Check(Plugin["properties"]["meta"]["properties"]["id"], _case)).toBe(true);
+        }
+    });
+});

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

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

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

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

package/dist/resolve-modules/resolveModules.js

@@ -0,0 +1,70 @@
+import { InlangModule } from "@inlang/module";
+import { ModuleError, ModuleImportError, ModuleHasNoExportsError, ModuleExportIsInvalidError, } 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";
+const ModuleCompiler = TypeCompiler.Compile(InlangModule);
+export const resolveModules = async (args) => {
+    const _import = args._import ?? createImport({ readFile: args.nodeishFs.readFile, fetch });
+    const moduleErrors = [];
+    const allPlugins = [];
+    const allMessageLintRules = [];
+    const meta = [];
+    for (const module of args.config.modules) {
+        /**
+         * -------------- BEGIN SETUP --------------
+         */
+        const importedModule = await tryCatch(() => _import(module));
+        // -- IMPORT MODULE --
+        if (importedModule.error) {
+            moduleErrors.push(new ModuleImportError(`Couldn't import the plugin "${module}"`, {
+                module: module,
+                cause: importedModule.error,
+            }));
+            continue;
+        }
+        // -- MODULE DOES NOT EXPORT PLUGINS OR LINT RULES --
+        if (importedModule.data?.default?.meta?.id === undefined) {
+            moduleErrors.push(new ModuleHasNoExportsError(`Module "${module}" has no exports.`, {
+                module: module,
+            }));
+            continue;
+        }
+        const isValidModule = ModuleCompiler.Check(importedModule.data);
+        if (isValidModule === false) {
+            const errors = [...ModuleCompiler.Errors(importedModule.data)];
+            moduleErrors.push(new ModuleExportIsInvalidError(`Module "${module}" is invalid: ` + errors, {
+                module: module,
+            }));
+            continue;
+        }
+        meta.push({
+            module: module,
+            id: importedModule.data.default.meta.id,
+        });
+        if (importedModule.data.default.meta.id.startsWith("plugin.")) {
+            allPlugins.push(importedModule.data.default);
+        }
+        else if (importedModule.data.default.meta.id.startsWith("messageLintRule.")) {
+            allMessageLintRules.push(importedModule.data.default);
+        }
+        else {
+            throw new Error(`Unimplemented module type. Must start with "plugin." or "messageLintRule.`);
+        }
+    }
+    const resolvedPlugins = await resolvePlugins({
+        plugins: allPlugins,
+        settings: args.config.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

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

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

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