@inlang/sdk 0.26.5 → 0.27.0

package/src/messages/variant.test.ts

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

package/src/resolve-modules/plugins/resolvePlugins.test.ts

@@ -70,7 +70,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({
@@ -84,7 +86,7 @@ describe("loadMessages", () => {
 				settings: {} as any,
 				nodeishFs: {} as any,
 			})
-		).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 () => {

package/src/storage/helper.ts

@@ -0,0 +1,48 @@
+import { Message, Variant } from "../versionedInterfaces.js"
+
+const fileExtension = ".json"
+
+export function getMessageIdFromPath(path: string) {
+	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: string) {
+	const path = id.replace("_", "/") + fileExtension
+	return path
+}
+
+export function stringifyMessage(message: Message) {
+	// create a new object do specify key output order
+	const messageWithSortedKeys: any = {}
+	for (const key of Object.keys(message).sort()) {
+		messageWithSortedKeys[key] = (message as any)[key]
+	}
+
+	// lets order variants as well
+	messageWithSortedKeys["variants"] = messageWithSortedKeys["variants"].sort(
+		(variantA: Variant, variantB: Variant) => {
+			// 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/src/storage/human-id/human-readable-id.ts

@@ -0,0 +1,27 @@
+// 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: string, offset: number = 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: number = (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/src/storage/human-id/words.test.ts

@@ -0,0 +1,27 @@
+import { describe, it, expect } from "vitest"
+import { adjectives, animals, adverbs, verbs } from "./words.js"
+
+const wordlists = [adjectives, animals, adverbs, verbs]
+const allwords = [...adjectives, ...animals, ...adverbs, ...verbs]
+
+describe("wordlists", () => {
+	it("should have 256 words", () => {
+		for (const wordlist of wordlists) {
+			expect(wordlist.length).toBe(256)
+		}
+	})
+	it("words should be unique across lists", () => {
+		const unique = new Set(allwords)
+		expect(unique.size).toBe(256 * 4)
+	})
+	it("words should have < 10 characters", () => {
+		for (const word of allwords) {
+			expect(word.length).toBeLessThan(10)
+		}
+	})
+	it("words should match /^[a-z]+$/", () => {
+		for (const word of allwords) {
+			expect(word.match(/^[a-z]+$/) !== null).toBe(true)
+		}
+	})
+})