@inlang/sdk 0.1.0

package/dist/lint/message/lintSingleMessage.js

@@ -0,0 +1,36 @@
+import { MessagedLintRuleThrowedError } from "./errors.js";
+/**
+ * Lint a single message.
+ *
+ * - the lint rule levels defaults to `warning`.
+ */
+export const lintSingleMessage = async (args) => {
+    const reports = [];
+    const errors = [];
+    const promises = args.rules.map(async (rule) => {
+        const ruleId = rule.meta.id;
+        const settings = args.ruleSettings?.[ruleId] ?? {};
+        const level = args.ruleLevels?.[ruleId];
+        if (level === undefined) {
+            throw Error("No lint level provided for lint rule: " + ruleId);
+        }
+        try {
+            await rule.message({
+                ...args,
+                settings,
+                report: (reportArgs) => {
+                    reports.push({
+                        ruleId,
+                        level,
+                        ...reportArgs,
+                    });
+                },
+            });
+        }
+        catch (error) {
+            errors.push(new MessagedLintRuleThrowedError(`Lint rule '${ruleId}' throwed while linting message "${args.message.id}".`, { cause: error }));
+        }
+    });
+    await Promise.all(promises);
+    return { data: reports, errors };
+};

package/dist/lint/message/lintSingleMessage.test.d.ts

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

package/dist/lint/message/lintSingleMessage.test.d.ts.map

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

package/dist/lint/message/lintSingleMessage.test.js

@@ -0,0 +1,155 @@
+import { beforeEach, describe, expect, test, vi } from "vitest";
+import { lintSingleMessage } from "./lintSingleMessage.js";
+import { tryCatch } from "@inlang/result";
+const lintRule1 = {
+    meta: {
+        id: "messageLintRule.r.1",
+        displayName: { en: "" },
+        description: { en: "" },
+    },
+    message: vi.fn(),
+};
+const lintRule2 = {
+    meta: {
+        id: "messageLintRule.r.2",
+        displayName: { en: "" },
+        description: { en: "" },
+    },
+    message: vi.fn(),
+};
+const message1 = {};
+const messages = [message1];
+describe("lintSingleMessage", async () => {
+    beforeEach(() => {
+        vi.resetAllMocks();
+    });
+    describe("resolve rules and settings", async () => {
+        // the lint function is un-opinionated and does not set a default level.
+        // opinionated users like the inlang instance can very well set a default level (separation of concerns)
+        test("it should throw if a lint level is not provided for a given lint rule", async () => {
+            lintRule1.message.mockImplementation(({ report }) => report({}));
+            const result = await tryCatch(() => lintSingleMessage({
+                ruleLevels: {},
+                ruleSettings: {},
+                sourceLanguageTag: "en",
+                languageTags: ["en"],
+                messages,
+                message: message1,
+                rules: [lintRule1],
+            }));
+            expect(result.error).toBeDefined();
+            expect(result.data).toBeUndefined();
+        });
+        test("it should override the default lint level", async () => {
+            lintRule1.message.mockImplementation(({ report }) => report({}));
+            const reports = await lintSingleMessage({
+                ruleLevels: {
+                    [lintRule1.meta.id]: "error",
+                },
+                ruleSettings: {},
+                sourceLanguageTag: "en",
+                languageTags: ["en"],
+                messages,
+                message: message1,
+                rules: [lintRule1],
+            });
+            expect(reports.data[0]?.level).toBe("error");
+        });
+        test("it should pass the correct settings", async () => {
+            const settings = {};
+            const fn = vi.fn();
+            lintRule1.message.mockImplementation(({ settings }) => fn(settings));
+            await lintSingleMessage({
+                ruleLevels: {
+                    [lintRule1.meta.id]: "warning",
+                },
+                ruleSettings: {
+                    [lintRule1.meta.id]: settings,
+                },
+                sourceLanguageTag: "en",
+                languageTags: ["en"],
+                messages,
+                message: message1,
+                rules: [lintRule1],
+            });
+            expect(fn).toHaveBeenCalledWith(settings);
+        });
+    });
+    test("it should await all rules", async () => {
+        let m1Called = false;
+        let m2Called = false;
+        lintRule1.message.mockImplementation(() => {
+            m1Called = true;
+        });
+        lintRule2.message.mockImplementation(async () => {
+            await new Promise((resolve) => setTimeout(resolve, 0));
+            m2Called = true;
+        });
+        await lintSingleMessage({
+            ruleLevels: {
+                [lintRule1.meta.id]: "warning",
+                [lintRule2.meta.id]: "warning",
+            },
+            ruleSettings: {},
+            sourceLanguageTag: "en",
+            languageTags: ["en"],
+            messages,
+            message: message1,
+            rules: [lintRule1, lintRule2],
+        });
+        expect(m1Called).toBe(true);
+        expect(m2Called).toBe(true);
+    });
+    test("it should process all rules in parallel", async () => {
+        const fn = vi.fn();
+        lintRule1.message.mockImplementation(async () => {
+            fn(lintRule1.meta.id, "before");
+            await new Promise((resolve) => setTimeout(resolve, 0));
+            fn(lintRule1.meta.id, "after");
+        });
+        lintRule2.message.mockImplementation(async () => {
+            fn(lintRule2.meta.id, "before");
+            await new Promise((resolve) => setTimeout(resolve, 0));
+            fn(lintRule2.meta.id, "after");
+        });
+        await lintSingleMessage({
+            ruleLevels: {
+                [lintRule1.meta.id]: "warning",
+                [lintRule2.meta.id]: "warning",
+            },
+            ruleSettings: {},
+            sourceLanguageTag: "en",
+            languageTags: ["en"],
+            messages,
+            message: message1,
+            rules: [lintRule1, lintRule2],
+        });
+        expect(fn).toHaveBeenCalledTimes(4);
+        expect(fn).toHaveBeenNthCalledWith(1, lintRule1.meta.id, "before");
+        expect(fn).toHaveBeenNthCalledWith(2, lintRule2.meta.id, "before");
+        expect(fn).toHaveBeenNthCalledWith(3, lintRule1.meta.id, "after");
+        expect(fn).toHaveBeenNthCalledWith(4, lintRule2.meta.id, "after");
+    });
+    test("it should not abort the linting process when errors occur", async () => {
+        lintRule1.message.mockImplementation(() => {
+            throw new Error("error");
+        });
+        lintRule2.message.mockImplementation(({ report }) => {
+            report({});
+        });
+        const result = await lintSingleMessage({
+            ruleLevels: {
+                [lintRule1.meta.id]: "warning",
+                [lintRule2.meta.id]: "warning",
+            },
+            ruleSettings: {},
+            sourceLanguageTag: "en",
+            languageTags: ["en"],
+            messages,
+            message: message1,
+            rules: [lintRule1, lintRule2],
+        });
+        expect(result.data).length(1);
+        expect(result.errors).length(1);
+    });
+});

package/dist/messages/errors.d.ts

@@ -0,0 +1,13 @@
+export declare class MessageVariantDoesNotExistError extends Error {
+    #private;
+    constructor(messageId: string, languageTag: string);
+}
+export declare class MessageVariantAlreadyExistsError extends Error {
+    #private;
+    constructor(messageId: string, languageTag: string);
+}
+export declare class MessagePatternsForLanguageTagDoNotExistError extends Error {
+    #private;
+    constructor(messageId: string, languageTag: string);
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/messages/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/messages/errors.ts"],"names":[],"mappings":"AAAA,qBAAa,+BAAgC,SAAQ,KAAK;;gBAG7C,SAAS,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM;CAKlD;AACD,qBAAa,gCAAiC,SAAQ,KAAK;;gBAG9C,SAAS,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM;CAKlD;AACD,qBAAa,4CAA6C,SAAQ,KAAK;;gBAG1D,SAAS,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM;CAGlD"}

package/dist/messages/errors.js

@@ -0,0 +1,18 @@
+export class MessageVariantDoesNotExistError extends Error {
+    #id = "MessageVariantDoesNotExistError";
+    constructor(messageId, languageTag) {
+        super(`For message '${messageId}' and '${languageTag}', there doesn't exist a variant for this specific matchers.`);
+    }
+}
+export class MessageVariantAlreadyExistsError extends Error {
+    #id = "MessageVariantAlreadyExistsError";
+    constructor(messageId, languageTag) {
+        super(`For message '${messageId}' and '${languageTag}', there already exists a variant for this specific matchers.`);
+    }
+}
+export class MessagePatternsForLanguageTagDoNotExistError extends Error {
+    #id = "MessagePatternsForLanguageTagDoNotExistError";
+    constructor(messageId, languageTag) {
+        super(`For message '${messageId}' there are no patterns with the languageTag '${languageTag}'.`);
+    }
+}

package/dist/messages/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./variant.js";
+export * from "./errors.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/messages/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/messages/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAA;AAC5B,cAAc,aAAa,CAAA"}

package/dist/messages/index.js

@@ -0,0 +1,2 @@
+export * from "./variant.js";
+export * from "./errors.js";

package/dist/messages/variant.d.ts

@@ -0,0 +1,46 @@
+import type { LanguageTag, Message, Variant } from "../versionedInterfaces.js";
+import type { Result } from "@inlang/result";
+import { MessagePatternsForLanguageTagDoNotExistError, MessageVariantAlreadyExistsError, MessageVariantDoesNotExistError } from "./errors.js";
+/**
+ * Tries to match the most specific variant of a message.
+ *
+ * The selectors determine the specificity of a variant. If no selectors are provided,
+ * or if the selectors do not match any variant, the catch all variant is returned
+ * (if it exists).
+ *
+ * @example
+ * 	const variant = getVariant(message, { where: { languageTag: "en", selectors: { gender: "male" }}});
+ */
+export declare function getVariant(message: Message, args: {
+    where: {
+        languageTag: LanguageTag;
+        selectors?: Variant["match"];
+    };
+}): Variant | undefined;
+/**
+ * Create a variant for a message
+ *
+ * All actions are immutable.
+ *
+ * @example
+ *  const message = createVariant(message, { languageTag: "en", data: variant })
+ */
+export declare function createVariant(message: Message, args: {
+    data: Variant;
+}): Result<Message, MessageVariantAlreadyExistsError>;
+/**
+ * Update a variant of a message
+ *
+ * All actions are immutable.
+ *
+ * @example
+ *  const message = updateVariant(message, { languageTag: "en", selectors: { gender: "male" }, pattern: []})
+ */
+export declare function updateVariantPattern(message: Message, args: {
+    where: {
+        languageTag: LanguageTag;
+        selectors: Record<string, string>;
+    };
+    data: Variant["pattern"];
+}): Result<Message, MessageVariantDoesNotExistError | MessagePatternsForLanguageTagDoNotExistError>;
+//# sourceMappingURL=variant.d.ts.map

package/dist/messages/variant.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"variant.d.ts","sourceRoot":"","sources":["../../src/messages/variant.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,2BAA2B,CAAA;AAC9E,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAA;AAC5C,OAAO,EACN,4CAA4C,EAC5C,gCAAgC,EAChC,+BAA+B,EAC/B,MAAM,aAAa,CAAA;AAEpB;;;;;;;;;GASG;AACH,wBAAgB,UAAU,CACzB,OAAO,EAAE,OAAO,EAChB,IAAI,EAAE;IACL,KAAK,EAAE;QACN,WAAW,EAAE,WAAW,CAAA;QACxB,SAAS,CAAC,EAAE,OAAO,CAAC,OAAO,CAAC,CAAA;KAC5B,CAAA;CACD,GACC,OAAO,GAAG,SAAS,CASrB;AAED;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAC5B,OAAO,EAAE,OAAO,EAChB,IAAI,EAAE;IACL,IAAI,EAAE,OAAO,CAAA;CACb,GACC,MAAM,CAAC,OAAO,EAAE,gCAAgC,CAAC,CAcnD;AAED;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CACnC,OAAO,EAAE,OAAO,EAChB,IAAI,EAAE;IACL,KAAK,EAAE;QACN,WAAW,EAAE,WAAW,CAAA;QACxB,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;KACjC,CAAA;IACD,IAAI,EAAE,OAAO,CAAC,SAAS,CAAC,CAAA;CACxB,GACC,MAAM,CAAC,OAAO,EAAE,+BAA+B,GAAG,4CAA4C,CAAC,CAqBjG"}

package/dist/messages/variant.js

@@ -0,0 +1,177 @@
+import { MessagePatternsForLanguageTagDoNotExistError, MessageVariantAlreadyExistsError, MessageVariantDoesNotExistError, } from "./errors.js";
+/**
+ * Tries to match the most specific variant of a message.
+ *
+ * The selectors determine the specificity of a variant. If no selectors are provided,
+ * or if the selectors do not match any variant, the catch all variant is returned
+ * (if it exists).
+ *
+ * @example
+ * 	const variant = getVariant(message, { where: { languageTag: "en", selectors: { gender: "male" }}});
+ */
+export function getVariant(message, args) {
+    const variant = matchMostSpecificVariant(message, args.where.languageTag, args.where.selectors);
+    if (variant) {
+        //! do not return a reference to the message in a resource
+        //! modifications to the returned message will leak into the
+        //! resource which is considered to be immutable.
+        return structuredClone(variant);
+    }
+    return undefined;
+}
+/**
+ * Create a variant for a message
+ *
+ * All actions are immutable.
+ *
+ * @example
+ *  const message = createVariant(message, { languageTag: "en", data: variant })
+ */
+export function createVariant(message, args) {
+    const copy = structuredClone(message);
+    // check if variant already exists
+    if (matchVariant(copy, args.data.languageTag, args.data.match)) {
+        return { error: new MessageVariantAlreadyExistsError(message.id, args.data.languageTag) };
+    }
+    // need to resolve selectors to match length and order of message selectors
+    copy.variants.push({
+        ...args.data,
+        match: resolveSelector(copy.selectors, args.data.match),
+    });
+    return { data: copy };
+}
+/**
+ * Update a variant of a message
+ *
+ * All actions are immutable.
+ *
+ * @example
+ *  const message = updateVariant(message, { languageTag: "en", selectors: { gender: "male" }, pattern: []})
+ */
+export function updateVariantPattern(message, args) {
+    const copy = structuredClone(message);
+    const containsLanguageTag = message.variants.some((variant) => variant.languageTag === args.where.languageTag);
+    if (!containsLanguageTag) {
+        return {
+            error: new MessagePatternsForLanguageTagDoNotExistError(message.id, args.where.languageTag),
+        };
+    }
+    const variant = matchVariant(copy, args.where.languageTag, args.where.selectors);
+    if (variant === undefined) {
+        return { error: new MessageVariantDoesNotExistError(message.id, args.where.languageTag) };
+    }
+    if (variant) {
+        variant.pattern = args.data;
+        return { data: copy };
+    }
+    return { error: new MessageVariantDoesNotExistError(message.id, args.where.languageTag) };
+}
+/**
+ * Returns the specific variant defined by selectors or undefined
+ *
+ * @example
+ *  const variant = matchVariant(message, languageTag: "en", selectors: { gender: "male" })
+ */
+const matchVariant = (message, languageTag, selectors) => {
+    // resolve preferenceSelectors to match length and order of message selectors
+    const resolvedSelectors = resolveSelector(message.selectors, selectors);
+    const languageVariants = message.variants.filter((variant) => variant.languageTag === languageTag);
+    if (languageVariants.length === 0)
+        return undefined;
+    for (const variant of languageVariants) {
+        let isMatch = true;
+        //check if vaiant is a match
+        for (const [key, value] of Object.entries(variant.match)) {
+            if (resolvedSelectors[key] !== value) {
+                isMatch = false;
+            }
+        }
+        if (isMatch) {
+            return variant;
+        }
+    }
+    return undefined;
+};
+/**
+ * Returns the most specific variant of a message.
+ *
+ * @example
+ *  const variant = matchMostSpecificVariant(message, languageTag: "en", selectors: { gender: "male" })
+ */
+const matchMostSpecificVariant = (message, languageTag, selectors) => {
+    // make selector undefined if empty object
+    selectors = JSON.stringify(selectors) === "{}" ? undefined : selectors;
+    // resolve preferenceSelectors to match length and order of message selectors
+    const resolvedSelectors = resolveSelector(message.selectors, selectors);
+    const index = {};
+    const languageVariants = message.variants.filter((variant) => variant.languageTag === languageTag);
+    if (languageVariants.length === 0)
+        return undefined;
+    for (const variant of languageVariants) {
+        let isMatch = true;
+        //check if variant is a match
+        for (const [key, value] of Object.entries(variant.match)) {
+            if (resolvedSelectors[key] !== value && value !== "*") {
+                isMatch = false;
+            }
+        }
+        if (isMatch && selectors) {
+            // add variant to nested index
+            // eslint-disable-next-line no-inner-declarations
+            function recursiveAddToIndex(currentIndex, currentKeys, variant) {
+                if (currentKeys[0]?.name) {
+                    const key = variant.match[currentKeys[0].name];
+                    if (key) {
+                        if (currentKeys.length === 1) {
+                            currentIndex[key] = variant;
+                        }
+                        else {
+                            if (!currentIndex[key]) {
+                                currentIndex[key] = {};
+                            }
+                            recursiveAddToIndex(currentIndex[key], currentKeys.slice(1), variant);
+                        }
+                    }
+                }
+            }
+            recursiveAddToIndex(index, message.selectors, variant);
+        }
+        else if (isMatch && !selectors) {
+            return variant;
+        }
+    }
+    //find the most specific variant
+    const findOptimalMatch = (index, selectors) => {
+        const keys = Object.keys(index);
+        for (const key of keys) {
+            if (key === selectors[0] || key === "*") {
+                const nextOptimal = selectors.slice(1);
+                if (nextOptimal.length === 0) {
+                    return index[key] || undefined;
+                }
+                const match = findOptimalMatch(index[key], nextOptimal);
+                if (match !== undefined) {
+                    return match;
+                }
+            }
+        }
+        return undefined;
+    };
+    return findOptimalMatch(index, Object.values(resolvedSelectors));
+};
+/**
+ * Returns resolved selector.
+ * -> Adds all possible selectors, if not defined it adds '*'. Order is determined by messageSelectors
+ *
+ * @example
+ *  const variant = resolveSelector(["gender","count"], selector: {count: "2"})
+ */
+const resolveSelector = (messageSelectors, selectors) => {
+    const resolvedSelectors = {};
+    if (!selectors)
+        return {};
+    for (const messageSelector of messageSelectors) {
+        resolvedSelectors[messageSelector.name] = selectors[messageSelector.name] ?? "*";
+    }
+    return resolvedSelectors;
+};

package/dist/messages/variant.test.d.ts

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

package/dist/messages/variant.test.d.ts.map

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