@inlang/sdk 0.26.5 → 0.27.0

package/dist/loadProject.test.js

@@ -45,6 +45,7 @@ const mockPlugin = {
 const exampleMessages = [
     {
         id: "a",
+        alias: {},
         selectors: [],
         variants: [
             {
@@ -61,6 +62,47 @@ const exampleMessages = [
     },
     {
         id: "b",
+        alias: {},
+        selectors: [],
+        variants: [
+            {
+                languageTag: "en",
+                match: [],
+                pattern: [
+                    {
+                        type: "Text",
+                        value: "test",
+                    },
+                ],
+            },
+        ],
+    },
+];
+const exampleAliasedMessages = [
+    {
+        id: "raw_tapir_pause_grateful",
+        alias: {
+            default: "a",
+        },
+        selectors: [],
+        variants: [
+            {
+                languageTag: "en",
+                match: [],
+                pattern: [
+                    {
+                        type: "Text",
+                        value: "test",
+                    },
+                ],
+            },
+        ],
+    },
+    {
+        id: "dizzy_halibut_dial_vaguely",
+        alias: {
+            default: "b",
+        },
         selectors: [],
         variants: [
             {
@@ -449,7 +491,7 @@ describe("functionality", () => {
                 id: "plugin.project.i18next",
                 description: { en: "Mock plugin description" },
                 displayName: { en: "Mock Plugin" },
-                loadMessages: () => [{ id: "some-message", selectors: [], variants: [] }],
+                loadMessages: () => [{ id: "some-message", alias: {}, selectors: [], variants: [] }],
                 saveMessages: () => undefined,
             };
             const repo = await mockRepo();
@@ -492,7 +534,7 @@ describe("functionality", () => {
                 id: "plugin.project.i18next",
                 description: { en: "Mock plugin description" },
                 displayName: { en: "Mock Plugin" },
-                loadMessages: () => [{ id: "some-message", selectors: [], variants: [] }],
+                loadMessages: () => [{ id: "some-message", alias: {}, selectors: [], variants: [] }],
                 saveMessages: () => undefined,
             };
             const repo = await mockRepo();
@@ -563,6 +605,20 @@ describe("functionality", () => {
             expect(Object.values(project.query.messages.getAll())).toEqual(exampleMessages);
         });
     });
+    describe("messages with aliases", () => {
+        it("should return the messages", async () => {
+            const repo = await mockRepo();
+            const fs = repo.nodeishFs;
+            await fs.mkdir("/user/project.inlang", { recursive: true });
+            await fs.writeFile("/user/project.inlang/settings.json", JSON.stringify({ ...settings, experimental: { aliases: true } }));
+            const project = await loadProject({
+                projectPath: "/user/project.inlang",
+                repo,
+                _import,
+            });
+            expect(Object.values(project.query.messages.getAll())).toEqual(exampleAliasedMessages);
+        });
+    });
     describe("query", () => {
         it("should call saveMessages() on updates", async () => {
             const repo = await mockRepo();
@@ -600,6 +656,7 @@ describe("functionality", () => {
                 where: { id: "a" },
                 data: {
                     id: "a",
+                    alias: {},
                     selectors: [],
                     variants: [
                         {
@@ -629,6 +686,7 @@ describe("functionality", () => {
                 where: { id: "b" },
                 data: {
                     id: "b",
+                    alias: {},
                     selectors: [],
                     variants: [
                         {
@@ -654,31 +712,33 @@ describe("functionality", () => {
                     ],
                 },
             });
-            await new Promise((resolve) => setTimeout(resolve, 510));
+            // lets wait for the next tick
+            await new Promise((resolve) => setTimeout(resolve, 100));
             expect(mockSaveFn.mock.calls.length).toBe(1);
             expect(mockSaveFn.mock.calls[0][0].settings).toStrictEqual(settings);
             expect(Object.values(mockSaveFn.mock.calls[0][0].messages)).toStrictEqual([
                 {
                     id: "a",
+                    alias: {},
                     selectors: [],
                     variants: [
                         {
-                            languageTag: "en",
+                            languageTag: "de",
                             match: [],
                             pattern: [
                                 {
                                     type: "Text",
-                                    value: "a en",
+                                    value: "a de",
                                 },
                             ],
                         },
                         {
-                            languageTag: "de",
+                            languageTag: "en",
                             match: [],
                             pattern: [
                                 {
                                     type: "Text",
-                                    value: "a de",
+                                    value: "a en",
                                 },
                             ],
                         },
@@ -686,25 +746,26 @@ describe("functionality", () => {
                 },
                 {
                     id: "b",
+                    alias: {},
                     selectors: [],
                     variants: [
                         {
-                            languageTag: "en",
+                            languageTag: "de",
                             match: [],
                             pattern: [
                                 {
                                     type: "Text",
-                                    value: "b en",
+                                    value: "b de",
                                 },
                             ],
                         },
                         {
-                            languageTag: "de",
+                            languageTag: "en",
                             match: [],
                             pattern: [
                                 {
                                     type: "Text",
-                                    value: "b de",
+                                    value: "b en",
                                 },
                             ],
                         },
@@ -766,6 +827,14 @@ describe("functionality", () => {
             await new Promise((resolve) => setTimeout(resolve, 510));
             expect(mockSaveFn.mock.calls.length).toBe(1);
             expect(mockSaveFn.mock.calls[0][0].messages).toHaveLength(4);
+            project.query.messages.create({ data: createMessage("fifth", { en: "fifth message" }) });
+            await new Promise((resolve) => setTimeout(resolve, 510));
+            expect(mockSaveFn.mock.calls.length).toBe(2);
+            expect(mockSaveFn.mock.calls[1][0].messages).toHaveLength(5);
+            project.query.messages.delete({ where: { id: "fourth" } });
+            await new Promise((resolve) => setTimeout(resolve, 510));
+            expect(mockSaveFn.mock.calls.length).toBe(3);
+            expect(mockSaveFn.mock.calls[2][0].messages).toHaveLength(4);
         });
     });
     describe("lint", () => {
@@ -868,14 +937,22 @@ describe("functionality", () => {
             project.query.messages.getAll.subscribe(() => {
                 counter = counter + 1;
             });
+            // subscribe fires once
             expect(counter).toBe(1);
-            // change file
+            // saving the file without changing should not trigger a message query
             await fs.writeFile("./messages.json", JSON.stringify(messages));
-            await new Promise((resolve) => setTimeout(resolve, 0));
+            await new Promise((resolve) => setTimeout(resolve, 200)); // file event will lock a file and be handled sequentially - give it time to pickup the change
+            // we didn't change the message we write into message.json - shouldn't change the messages
+            expect(counter).toBe(1);
+            // saving the file without changing should trigger a change
+            messages.data[0].variants[0].pattern[0].value = "changed";
+            await fs.writeFile("./messages.json", JSON.stringify(messages));
+            await new Promise((resolve) => setTimeout(resolve, 200)); // file event will lock a file and be handled sequentially - give it time to pickup the change
             expect(counter).toBe(2);
+            messages.data[0].variants[0].pattern[0].value = "changed3";
             // change file
             await fs.writeFile("./messages.json", JSON.stringify(messages));
-            await new Promise((resolve) => setTimeout(resolve, 0));
+            await new Promise((resolve) => setTimeout(resolve, 200)); // file event will lock a file and be handled sequentially - give it time to pickup the change
             expect(counter).toBe(3);
         });
     });

package/dist/messages/variant.test.js

@@ -32,6 +32,7 @@ describe("getVariant", () => {
     test("it should not throw error if selector is empty and match", () => {
         const mockMessage = {
             id: "mockMessage",
+            alias: {},
             selectors: [],
             variants: [
                 {
@@ -57,6 +58,7 @@ describe("getVariant", () => {
     test("it should not throw error if selector is empty, return undefined", () => {
         const mockMessage = {
             id: "mockMessage",
+            alias: {},
             selectors: [],
             variants: [
                 {
@@ -326,6 +328,7 @@ describe("updateVariant", () => {
 const getMockMessage = () => {
     return {
         id: "first-message",
+        alias: {},
         selectors: [
             { type: "VariableReference", name: "gender" },
             { type: "VariableReference", name: "guestOther" },

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

@@ -57,7 +57,9 @@ describe("loadMessages", () => {
             id: "plugin.namespace.placeholder",
             description: { en: "My plugin description" },
             displayName: { en: "My plugin" },
-            loadMessages: async () => [{ id: "test", expressions: [], selectors: [], variants: [] }],
+            loadMessages: async () => [
+                { id: "test", alias: {}, expressions: [], selectors: [], variants: [] },
+            ],
         };
         const resolved = await resolvePlugins({
             plugins: [mockPlugin],
@@ -67,7 +69,7 @@ describe("loadMessages", () => {
         expect(await resolved.data.loadMessages({
             settings: {},
             nodeishFs: {},
-        })).toEqual([{ id: "test", expressions: [], selectors: [], variants: [] }]);
+        })).toEqual([{ id: "test", alias: {}, expressions: [], selectors: [], variants: [] }]);
     });
     it("should collect an error if function is defined twice in multiple plugins", async () => {
         const mockPlugin = {

package/dist/storage/helper.d.ts

@@ -0,0 +1,5 @@
+import { Message } from "../versionedInterfaces.js";
+export declare function getMessageIdFromPath(path: string): string | undefined;
+export declare function getPathFromMessageId(id: string): string;
+export declare function stringifyMessage(message: Message): string;
+//# sourceMappingURL=helper.d.ts.map

package/dist/storage/helper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helper.d.ts","sourceRoot":"","sources":["../../src/storage/helper.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAW,MAAM,2BAA2B,CAAA;AAI5D,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,sBAahD;AAED,wBAAgB,oBAAoB,CAAC,EAAE,EAAE,MAAM,UAG9C;AAED,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,OAAO,UAuBhD"}

package/dist/storage/helper.js

@@ -0,0 +1,35 @@
+import { Message, Variant } from "../versionedInterfaces.js";
+const fileExtension = ".json";
+export function getMessageIdFromPath(path) {
+    if (!path.endsWith(fileExtension)) {
+        return;
+    }
+    const cleanedPath = path.replace(/\/$/, ""); // This regex matches a trailing slash and replaces it with an empty string
+    const messageFileName = cleanedPath.split("/").join("_"); // we split by the first leading namespace or _ separator - make sure slashes don't exit in the id
+    // const messageFileName = pathParts.at(-1)!
+    const lastDotIndex = messageFileName.lastIndexOf(".");
+    // Extract until the last dot (excluding the dot)
+    return messageFileName.slice(0, Math.max(0, lastDotIndex));
+}
+export function getPathFromMessageId(id) {
+    const path = id.replace("_", "/") + fileExtension;
+    return path;
+}
+export function stringifyMessage(message) {
+    // create a new object do specify key output order
+    const messageWithSortedKeys = {};
+    for (const key of Object.keys(message).sort()) {
+        messageWithSortedKeys[key] = message[key];
+    }
+    // lets order variants as well
+    messageWithSortedKeys["variants"] = messageWithSortedKeys["variants"].sort((variantA, variantB) => {
+        // First, compare by language
+        const languageComparison = variantA.languageTag.localeCompare(variantB.languageTag);
+        // If languages are the same, compare by match
+        if (languageComparison === 0) {
+            return variantA.match.join("-").localeCompare(variantB.match.join("-"));
+        }
+        return languageComparison;
+    });
+    return JSON.stringify(messageWithSortedKeys, undefined, 4);
+}

package/dist/storage/human-id/human-readable-id.d.ts

@@ -0,0 +1,3 @@
+export declare function randomHumanId(): string;
+export declare function humanIdHash(value: string, offset?: number): string;
+//# sourceMappingURL=human-readable-id.d.ts.map

package/dist/storage/human-id/human-readable-id.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"human-readable-id.d.ts","sourceRoot":"","sources":["../../../src/storage/human-id/human-readable-id.ts"],"names":[],"mappings":"AAIA,wBAAgB,aAAa,WAI5B;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,GAAE,MAAU,UAgB5D"}

package/dist/storage/human-id/human-readable-id.js

@@ -0,0 +1,20 @@
+// we use murmur for best distribution https://medium.com/miro-engineering/choosing-a-hash-function-to-solve-a-data-sharding-problem-c656259e2b54
+import murmurhash3 from "murmurhash3js";
+import { adjectives, animals, adverbs, verbs } from "./words.js";
+export function randomHumanId() {
+    return `${adjectives[Math.floor(Math.random() * 256)]}_${adjectives[Math.floor(Math.random() * 256)]}_${animals[Math.floor(Math.random() * 256)]}_${verbs[Math.floor(Math.random() * 256)]}`;
+}
+export function humanIdHash(value, offset = 0) {
+    // Seed value can be any arbitrary value
+    const seed = 42;
+    // Use MurmurHash3 to produce a 32-bit hash
+    const hash32 = murmurhash3.x86.hash32(value, seed);
+    // Add 1 and take modulo 2^32 to fit within 32 bits
+    const hash32WithOffset = (hash32 + offset) >>> 0;
+    // Extract four 8-bit parts
+    const part1 = (hash32WithOffset >>> 24) & 0xff;
+    const part2 = (hash32WithOffset >>> 16) & 0xff;
+    const part3 = (hash32WithOffset >>> 8) & 0xff;
+    const part4 = hash32WithOffset & 0xff;
+    return `${adjectives[part1]}_${animals[part2]}_${verbs[part3]}_${adverbs[part4]}`;
+}

package/dist/storage/human-id/words.d.ts

@@ -0,0 +1,5 @@
+export declare const animals: string[];
+export declare const adjectives: string[];
+export declare const adverbs: string[];
+export declare const verbs: string[];
+//# sourceMappingURL=words.d.ts.map

package/dist/storage/human-id/words.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"words.d.ts","sourceRoot":"","sources":["../../../src/storage/human-id/words.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,OAAO,UAiQnB,CAAA;AAED,eAAO,MAAM,UAAU,UAiQtB,CAAA;AAED,eAAO,MAAM,OAAO,UAiQnB,CAAA;AAED,eAAO,MAAM,KAAK,UAiQjB,CAAA"}