@inlang/sdk 0.1.0

package/dist/messages/variant.test.js

@@ -0,0 +1,379 @@
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+import { createVariant, getVariant, updateVariantPattern } from "./variant.js";
+import { describe, test, expect } from "vitest";
+import { MessagePatternsForLanguageTagDoNotExistError, MessageVariantAlreadyExistsError, MessageVariantDoesNotExistError, } from "./errors.js";
+describe("getVariant", () => {
+    test("should return the correct variant of a message", () => {
+        const mockMessage = getMockMessage();
+        const variant = getVariant(mockMessage, {
+            where: {
+                languageTag: "en",
+                selectors: { gender: "female", guestOther: "1" },
+            },
+        });
+        expect(variant?.pattern[0]).toStrictEqual({
+            type: "Text",
+            value: "{$hostName} invites {$guestName} to her party.",
+        });
+    });
+    test("should return the correct fallback because the exact match does not exist", () => {
+        const mockMessage = getMockMessage();
+        const variant = getVariant(mockMessage, {
+            where: {
+                languageTag: "en",
+                selectors: { gender: "female", guestOther: "0" },
+            },
+        });
+        expect(variant?.pattern[0]).toStrictEqual({
+            type: "Text",
+            value: "{$hostName} invites {$guestName} and {$guestsOther} other people to her party.",
+        });
+    });
+    test("it should return undefined (but never throw an error) if selectors is an empty array", () => {
+        const mockMessage = {
+            id: "mockMessage",
+            selectors: [],
+            variants: [
+                {
+                    languageTag: "en",
+                    pattern: [{ type: "Text", value: "Gender male" }],
+                    match: {
+                        gender: "male",
+                    },
+                },
+                {
+                    languageTag: "de",
+                    pattern: [{ type: "Text", value: "Veraltete Übersetzung" }],
+                    match: {},
+                },
+            ],
+        };
+        const variant = getVariant(mockMessage, {
+            where: {
+                languageTag: "fr",
+                selectors: {},
+            },
+        });
+        expect(variant).toBeUndefined();
+    });
+    test("the matcher should resolve not existing selectors to '*'", () => {
+        const mockMessage = getMockMessage();
+        const variant = getVariant(mockMessage, {
+            where: {
+                languageTag: "en",
+                selectors: { guestOther: "0" },
+            },
+        });
+        expect(variant?.pattern[0]).toStrictEqual({
+            type: "Text",
+            value: "{$hostName} does not give a party.",
+        });
+    });
+    test("empty selector should result in '*','*'", () => {
+        const mockMessage = getMockMessage();
+        const variant = getVariant(mockMessage, {
+            where: {
+                languageTag: "en",
+                selectors: {},
+            },
+        });
+        expect(variant?.pattern[0]).toStrictEqual({
+            type: "Text",
+            value: "{$hostName} invites {$guestName} and {$guestsOther} other people to their party.",
+        });
+    });
+    test("non existing selector values should be resolved", () => {
+        const mockMessage = getMockMessage();
+        const variant = getVariant(mockMessage, {
+            where: {
+                languageTag: "en",
+                selectors: { gender: "trans", guestOther: "2" },
+            },
+        });
+        expect(variant?.pattern[0]).toStrictEqual({
+            type: "Text",
+            value: "{$hostName} invites {$guestName} and one other person to their party.",
+        });
+        const variant2 = getVariant(mockMessage, {
+            where: {
+                languageTag: "en",
+                selectors: { gender: "male", guestOther: "8" },
+            },
+        });
+        expect(variant2?.pattern[0]).toStrictEqual({
+            type: "Text",
+            value: "{$hostName} invites {$guestName} and {$guestsOther} other people to his party.",
+        });
+    });
+    test("should return undefined of no variant matches", () => {
+        const mockMessage = getMockMessage();
+        mockMessage.variants = [
+            ...mockMessage.variants.filter((v) => v.languageTag === "en" && (v.match.gender !== "*" || v.match.guestOther !== "*")),
+        ];
+        const variant = getVariant(mockMessage, {
+            where: {
+                languageTag: "en",
+                selectors: {},
+            },
+        });
+        expect(variant).toBeUndefined();
+    });
+    test("should return undefined if a variant for specific language does not exist", () => {
+        const mockMessage = getMockMessage();
+        const variant = getVariant(mockMessage, {
+            where: {
+                languageTag: "de",
+                selectors: { gender: "female", guestOther: "1" },
+            },
+        });
+        expect(variant).toBeUndefined();
+    });
+    test("should return the catch all variant if no selector defined", () => {
+        const mockMessage = {};
+        mockMessage.variants = [
+            {
+                languageTag: "en",
+                match: {},
+                pattern: [
+                    {
+                        type: "Text",
+                        value: "test",
+                    },
+                ],
+            },
+        ];
+        const variant = getVariant(mockMessage, {
+            where: {
+                languageTag: "en",
+                selectors: {},
+            },
+        });
+        // should return the female variant
+        expect(variant?.pattern[0]).toStrictEqual({
+            type: "Text",
+            value: "test",
+        });
+    });
+});
+describe("createVariant", () => {
+    test("should create a variant for a message", () => {
+        const mockMessage = getMockMessage();
+        const newVariant = {
+            languageTag: "en",
+            match: { gender: "female", guestOther: "0" },
+            pattern: [],
+        };
+        const message = createVariant(mockMessage, {
+            data: newVariant,
+        });
+        // should return the female variant
+        expect(message.data.variants.find((v) => v.languageTag === "en" && v.match.gender === "female" && v.match.guestOther === "0")?.pattern).toStrictEqual([]);
+    });
+    test("should create a variant, also if matcher are not full defined", () => {
+        const mockMessage = getMockMessage();
+        mockMessage.variants = [
+            ...mockMessage.variants.filter((v) => v.languageTag === "en" && (v.match.gender !== "*" || v.match.guestOther !== "*")),
+        ];
+        const message = createVariant(mockMessage, {
+            data: {
+                languageTag: "en",
+                match: {},
+                pattern: [],
+            },
+        });
+        // should return the female variant
+        expect(message.data.variants.find((v) => v.languageTag === "en" && v.match.gender === "*" && v.match.guestOther === "*")?.pattern).toStrictEqual([]);
+    });
+    test("should return error if variant matches", () => {
+        const mockMessage = getMockMessage();
+        const variant = createVariant(mockMessage, {
+            data: {
+                languageTag: "en",
+                match: { gender: "male", guestOther: "1" },
+                pattern: [],
+            },
+        });
+        // should return the female variant
+        expect(variant.data).toBeUndefined();
+        expect(variant.error).toBeInstanceOf(MessageVariantAlreadyExistsError);
+    });
+    test("should not return error if set of variants for specific language does not exist", () => {
+        const mockMessage = getMockMessage();
+        const variant = createVariant(mockMessage, {
+            data: {
+                languageTag: "de",
+                match: { gender: "female", guestOther: "1" },
+                pattern: [],
+            },
+        });
+        // should return the female variant
+        expect(variant.data).toBeDefined();
+        expect(variant.error).toBeUndefined();
+    });
+});
+describe("updateVariant", () => {
+    test("should update a variant of a message", () => {
+        const mockMessage = getMockMessage();
+        const message = updateVariantPattern(mockMessage, {
+            where: {
+                languageTag: "en",
+                selectors: { gender: "female", guestOther: "1" },
+            },
+            data: [],
+        });
+        // should return the female variant
+        expect(message.data.variants.find((v) => v.languageTag === "en" && v.match.gender === "female" && v.match.guestOther === "1")?.pattern).toStrictEqual([]);
+    });
+    test("should update a variant, also if matcher are not full defined", () => {
+        const mockMessage = getMockMessage();
+        const message = updateVariantPattern(mockMessage, {
+            where: {
+                languageTag: "en",
+                selectors: {},
+            },
+            data: [],
+        });
+        // should return the female variant
+        expect(message.data.variants.find((v) => v.languageTag === "en" && v.match.gender === "*" && v.match.guestOther === "*")?.pattern).toStrictEqual([]);
+    });
+    test("should return error if no variant matches", () => {
+        const mockMessage = getMockMessage();
+        mockMessage.variants = [
+            ...mockMessage.variants.filter((v) => v.languageTag === "en" && (v.match.gender !== "*" || v.match.guestOther !== "*")),
+        ];
+        const variant = updateVariantPattern(mockMessage, {
+            where: {
+                languageTag: "en",
+                selectors: {},
+            },
+            data: [],
+        });
+        // should return the female variant
+        expect(variant.data).toBeUndefined();
+        expect(variant.error).toBeInstanceOf(MessageVariantDoesNotExistError);
+    });
+    test("should return error if set of variants for specific language does not exist", () => {
+        const mockMessage = getMockMessage();
+        const variant = updateVariantPattern(mockMessage, {
+            where: {
+                languageTag: "de",
+                selectors: {},
+            },
+            data: [],
+        });
+        // should return the female variant
+        expect(variant.data).toBeUndefined();
+        expect(variant.error).toBeInstanceOf(MessagePatternsForLanguageTagDoNotExistError);
+    });
+});
+const getMockMessage = () => {
+    return {
+        id: "first-message",
+        selectors: [
+            { type: "VariableReference", name: "gender" },
+            { type: "VariableReference", name: "guestOther" },
+        ],
+        variants: [
+            {
+                languageTag: "en",
+                match: { gender: "female", guestOther: "1" },
+                pattern: [
+                    {
+                        type: "Text",
+                        value: "{$hostName} invites {$guestName} to her party.",
+                    },
+                ],
+            },
+            {
+                languageTag: "en",
+                match: { gender: "female", guestOther: "2" },
+                pattern: [
+                    {
+                        type: "Text",
+                        value: "{$hostName} invites {$guestName} and one other person to her party.",
+                    },
+                ],
+            },
+            {
+                languageTag: "en",
+                match: { gender: "female", guestOther: "*" },
+                pattern: [
+                    {
+                        type: "Text",
+                        value: "{$hostName} invites {$guestName} and {$guestsOther} other people to her party.",
+                    },
+                ],
+            },
+            {
+                languageTag: "en",
+                match: { gender: "male", guestOther: "1" },
+                pattern: [
+                    {
+                        type: "Text",
+                        value: "{$hostName} invites {$guestName} to his party.",
+                    },
+                ],
+            },
+            {
+                languageTag: "en",
+                match: { gender: "male", guestOther: "2" },
+                pattern: [
+                    {
+                        type: "Text",
+                        value: "{$hostName} invites {$guestName} and one other person to his party.",
+                    },
+                ],
+            },
+            {
+                languageTag: "en",
+                match: { gender: "male", guestOther: "*" },
+                pattern: [
+                    {
+                        type: "Text",
+                        value: "{$hostName} invites {$guestName} and {$guestsOther} other people to his party.",
+                    },
+                ],
+            },
+            {
+                languageTag: "en",
+                match: { gender: "*", guestOther: "0" },
+                pattern: [
+                    {
+                        type: "Text",
+                        value: "{$hostName} does not give a party.",
+                    },
+                ],
+            },
+            {
+                languageTag: "en",
+                match: { gender: "*", guestOther: "1" },
+                pattern: [
+                    {
+                        type: "Text",
+                        value: "{$hostName} invites {$guestName} to their party.",
+                    },
+                ],
+            },
+            {
+                languageTag: "en",
+                match: { gender: "*", guestOther: "2" },
+                pattern: [
+                    {
+                        type: "Text",
+                        value: "{$hostName} invites {$guestName} and one other person to their party.",
+                    },
+                ],
+            },
+            {
+                languageTag: "en",
+                match: { gender: "*", guestOther: "*" },
+                pattern: [
+                    {
+                        type: "Text",
+                        value: "{$hostName} invites {$guestName} and {$guestsOther} other people to their party.",
+                    },
+                ],
+            },
+        ],
+    };
+};

package/dist/openInlangProject.d.ts

@@ -0,0 +1,18 @@
+import type { InlangProject, Subscribable } from "./api.js";
+import { type ImportFunction } from "./resolve-modules/index.js";
+import { type NodeishFilesystemSubset } from "./versionedInterfaces.js";
+/**
+ * Creates an inlang instance.
+ *
+ * - Use `_import` to pass a custom import function for testing,
+ *   and supporting legacy resolvedModules such as CJS.
+ *
+ */
+export declare const openInlangProject: (args: {
+    projectFilePath: string;
+    nodeishFs: NodeishFilesystemSubset;
+    _import?: ImportFunction | undefined;
+    _capture?: ((id: string, props: Record<string, unknown>) => void) | undefined;
+}) => Promise<InlangProject>;
+export declare function createSubscribable<T>(signal: () => T): Subscribable<T>;
+//# sourceMappingURL=openInlangProject.d.ts.map

package/dist/openInlangProject.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openInlangProject.d.ts","sourceRoot":"","sources":["../src/openInlangProject.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACX,aAAa,EAGb,YAAY,EACZ,MAAM,UAAU,CAAA;AACjB,OAAO,EAAE,KAAK,cAAc,EAAkB,MAAM,4BAA4B,CAAA;AAehF,OAAO,EAA0B,KAAK,uBAAuB,EAAE,MAAM,0BAA0B,CAAA;AAK/F;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB;qBACZ,MAAM;eACZ,uBAAuB;;qBAElB,MAAM,SAAS,OAAO,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI;MAC5D,QAAQ,aAAa,CAwLxB,CAAA;AAyGD,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,CAQtE"}

package/dist/openInlangProject.js

@@ -0,0 +1,226 @@
+import { resolveModules } from "./resolve-modules/index.js";
+import { TypeCompiler } from "@sinclair/typebox/compiler";
+import { Value } from "@sinclair/typebox/value";
+import { ProjectFilePathNotFoundError, ProjectFileJSONSyntaxError, InvalidConfigError, NoPluginProvidesLoadOrSaveMessagesError, PluginLoadMessagesError, PluginSaveMessagesError, } from "./errors.js";
+import { createRoot, createSignal, createEffect } from "./reactivity/solid.js";
+import { createMessagesQuery } from "./createMessagesQuery.js";
+import { debounce } from "throttle-debounce";
+import { createMessageLintReportsQuery } from "./createMessageLintReportsQuery.js";
+import { ProjectConfig, Message } from "./versionedInterfaces.js";
+import { tryCatch } from "@inlang/result";
+const ConfigCompiler = TypeCompiler.Compile(ProjectConfig);
+/**
+ * Creates an inlang instance.
+ *
+ * - Use `_import` to pass a custom import function for testing,
+ *   and supporting legacy resolvedModules such as CJS.
+ *
+ */
+export const openInlangProject = async (args) => {
+    return await createRoot(async () => {
+        const [initialized, markInitAsComplete, markInitAsFailed] = createAwaitable();
+        // -- config ------------------------------------------------------------
+        const [config, _setConfig] = createSignal();
+        createEffect(() => {
+            loadConfig({ projectFilePath: args.projectFilePath, nodeishFs: args.nodeishFs })
+                .then((config) => {
+                setConfig(config);
+                args._capture?.("SDK used config", config);
+            })
+                .catch((err) => {
+                markInitAsFailed(err);
+            });
+        });
+        // TODO: create FS watcher and update config on change
+        const writeConfigToDisk = skipFirst((config) => _writeConfigToDisk({ nodeishFs: args.nodeishFs, config }));
+        const setConfig = (config) => {
+            try {
+                const validatedConfig = validateConfig(config);
+                _setConfig(validatedConfig);
+                writeConfigToDisk(validatedConfig);
+                return { data: undefined };
+            }
+            catch (error) {
+                if (error instanceof InvalidConfigError) {
+                    return { error };
+                }
+                throw new Error("unhandled");
+            }
+        };
+        // -- resolvedModules -----------------------------------------------------------
+        const [resolvedModules, setResolvedModules] = createSignal();
+        createEffect(() => {
+            const conf = config();
+            if (!conf)
+                return;
+            loadModules({ config: conf, nodeishFs: args.nodeishFs, _import: args._import })
+                .then((resolvedModules) => {
+                // TODO move to resolveModules
+                if (!resolvedModules.resolvedPluginApi.loadMessages ||
+                    !resolvedModules.resolvedPluginApi.saveMessages) {
+                    throw new NoPluginProvidesLoadOrSaveMessagesError();
+                }
+                setResolvedModules(resolvedModules);
+                // TODO: handle `detectedLanguageTags`
+            })
+                .catch((err) => markInitAsFailed(err));
+        });
+        // -- messages ----------------------------------------------------------
+        let configValue;
+        createEffect(() => (configValue = config())); // workaround to not run effects twice (e.g. config change + modules change) (I'm sure there exists a solid way of doing this, but I haven't found it yet)
+        const [messages, setMessages] = createSignal();
+        createEffect(() => {
+            const conf = config();
+            if (!conf)
+                return;
+            const _resolvedModules = resolvedModules();
+            if (!_resolvedModules)
+                return;
+            if (!_resolvedModules.resolvedPluginApi.loadMessages) {
+                markInitAsFailed(undefined);
+                return;
+            }
+            makeTrulyAsync(_resolvedModules.resolvedPluginApi.loadMessages({
+                languageTags: configValue.languageTags,
+                sourceLanguageTag: configValue.sourceLanguageTag,
+            }))
+                .then((messages) => {
+                setMessages(messages);
+                markInitAsComplete();
+            })
+                .catch((err) => markInitAsFailed(new PluginLoadMessagesError("Error in load messages", { cause: err })));
+        });
+        // -- installed items ----------------------------------------------------
+        const installedMessageLintRules = () => {
+            if (!resolvedModules())
+                return [];
+            return resolvedModules().messageLintRules.map((rule) => ({
+                meta: rule.meta,
+                module: resolvedModules()?.meta.find((m) => m.id.includes(rule.meta.id))?.module ??
+                    "Unknown module. You stumbled on a bug in inlang's source code. Please open an issue.",
+                // default to warning, see https://github.com/inlang/inlang/issues/1254
+                lintLevel: configValue.settings["project.messageLintRuleLevels"]?.[rule.meta.id] ?? "warning",
+            }));
+        };
+        const installedPlugins = () => {
+            if (!resolvedModules())
+                return [];
+            return resolvedModules().plugins.map((plugin) => ({
+                meta: plugin.meta,
+                module: resolvedModules()?.meta.find((m) => m.id.includes(plugin.meta.id))?.module ??
+                    "Unknown module. You stumbled on a bug in inlang's source code. Please open an issue.",
+            }));
+        };
+        // -- app ---------------------------------------------------------------
+        const initializeError = await initialized.catch((error) => error);
+        const messagesQuery = createMessagesQuery(() => messages() || []);
+        const lintReportsQuery = createMessageLintReportsQuery(messages, config, installedMessageLintRules, resolvedModules);
+        const debouncedSave = skipFirst(debounce(500, async (newMessages) => {
+            try {
+                await resolvedModules().resolvedPluginApi.saveMessages({ messages: newMessages });
+            }
+            catch (err) {
+                throw new PluginSaveMessagesError("Error in saving messages", {
+                    cause: err,
+                });
+            }
+            if (newMessages.length !== 0 &&
+                JSON.stringify(newMessages) !== JSON.stringify(messages())) {
+                setMessages(newMessages);
+            }
+        }, { atBegin: false }));
+        createEffect(() => {
+            debouncedSave(messagesQuery.getAll());
+        });
+        return {
+            installed: {
+                plugins: createSubscribable(() => installedPlugins()),
+                messageLintRules: createSubscribable(() => installedMessageLintRules()),
+            },
+            errors: createSubscribable(() => [
+                ...(initializeError ? [initializeError] : []),
+                ...(resolvedModules() ? resolvedModules().errors : []),
+                // have a query error exposed
+                //...(lintErrors() ?? []),
+            ]),
+            config: createSubscribable(() => config()),
+            setConfig,
+            customApi: createSubscribable(() => resolvedModules()?.resolvedPluginApi.customApi || {}),
+            query: {
+                messages: messagesQuery,
+                messageLintReports: lintReportsQuery,
+            },
+        };
+    });
+};
+//const x = {} as InlangProject
+// ------------------------------------------------------------------------------------------------
+const loadConfig = async (args) => {
+    const { data: configFile, error: configFileError } = await tryCatch(async () => await args.nodeishFs.readFile(args.projectFilePath, { encoding: "utf-8" }));
+    if (configFileError)
+        throw new ProjectFilePathNotFoundError(`Could not locate config file in (${args.projectFilePath}).`, {
+            cause: configFileError,
+        });
+    const { data: parsedConfig, error: parseConfigError } = tryCatch(() => JSON.parse(configFile));
+    if (parseConfigError)
+        throw new ProjectFileJSONSyntaxError(`The config is not a valid JSON file.`, {
+            cause: parseConfigError,
+        });
+    return validateConfig(parsedConfig);
+};
+const validateConfig = (config) => {
+    const typeErrors = [...ConfigCompiler.Errors(config)];
+    if (typeErrors.length > 0) {
+        throw new InvalidConfigError(`The config is invalid according to the schema.`, {
+            cause: typeErrors,
+        });
+    }
+    // @ts-ignore - fix after refactor
+    return Value.Cast(ProjectConfig, config);
+};
+const _writeConfigToDisk = async (args) => {
+    const { data: serializedConfig, error: serializeConfigError } = tryCatch(() => 
+    // TODO: this will probably not match the original formatting
+    JSON.stringify(args.config, undefined, 2));
+    if (serializeConfigError)
+        throw serializeConfigError;
+    const { error: writeConfigError } = await tryCatch(async () => args.nodeishFs.writeFile("./project.inlang.json", serializedConfig));
+    if (writeConfigError)
+        throw writeConfigError;
+};
+// ------------------------------------------------------------------------------------------------
+const loadModules = async (args) => resolveModules({
+    config: args.config,
+    nodeishFs: args.nodeishFs,
+    _import: args._import,
+});
+const createAwaitable = () => {
+    let resolve;
+    let reject;
+    const promise = new Promise((res, rej) => {
+        resolve = res;
+        reject = rej;
+    });
+    return [promise, resolve, reject];
+};
+const makeTrulyAsync = (fn) => (async () => fn)();
+// Skip initial call, eg. to skip setup of a createEffect
+function skipFirst(func) {
+    let initial = false;
+    return function (...args) {
+        if (initial) {
+            // @ts-ignore
+            return func.apply(this, args);
+        }
+        initial = true;
+    };
+}
+export function createSubscribable(signal) {
+    return Object.assign(signal, {
+        subscribe: (callback) => {
+            createEffect(() => {
+                callback(signal());
+            });
+        },
+    });
+}

package/dist/openInlangProject.test.d.ts

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

package/dist/openInlangProject.test.d.ts.map

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