@inlang/sdk 0.34.9 → 0.34.10

package/src/loadProject.test.ts

@@ -635,8 +635,10 @@ describe("functionality", () => {
 
 			await new Promise((resolve) => setTimeout(resolve, 510))
 
-			expect(await project.query.messageLintReports.getAll()).toHaveLength(1)
-			expect((await project.query.messageLintReports.getAll())?.[0]?.ruleId).toBe(_mockLintRule.id)
+			expect(await project.query.messageLintReports.getAll.settled()).toHaveLength(1)
+			expect((await project.query.messageLintReports.getAll.settled())?.[0]?.ruleId).toBe(
+				_mockLintRule.id
+			)
 			expect(project.installed.messageLintRules()).toHaveLength(1)
 		})
 
@@ -1014,25 +1016,6 @@ describe("functionality", () => {
 	})
 
 	describe("lint", () => {
-		it.todo("should throw if lint reports are not initialized yet", async () => {
-			const repo = await mockRepo()
-			const fs = repo.nodeishFs
-			await fs.mkdir("/user/project", { recursive: true })
-			await fs.writeFile("/user/project/project.inlang.json", JSON.stringify(settings))
-			const project = await loadProject({
-				projectPath: "/user/project/project.inlang.json",
-				repo,
-				_import,
-			})
-			// TODO: test with real lint rules
-			try {
-				const r = await project.query.messageLintReports.getAll()
-				expect(r).toEqual(undefined)
-				throw new Error("Should not reach this")
-			} catch (e) {
-				expect((e as Error).message).toBe("lint not initialized yet")
-			}
-		})
 		it("should return the message lint reports", async () => {
 			const settings: ProjectSettings = {
 				sourceLanguageTag: "en",
@@ -1051,7 +1034,7 @@ describe("functionality", () => {
 				}),
 			})
 			// TODO: test with real lint rules
-			const r = await project.query.messageLintReports.getAll()
+			const r = await project.query.messageLintReports.getAll.settled()
 			expect(r).toEqual([])
 		})
 	})
@@ -1083,6 +1066,23 @@ describe("functionality", () => {
 				],
 			}
 
+			const newMessage = {
+				id: "test2",
+				selectors: [],
+				variants: [
+					{
+						match: [],
+						languageTag: "en",
+						pattern: [
+							{
+								type: "Text",
+								value: "test",
+							},
+						],
+					},
+				],
+			}
+
 			await fs.writeFile("./messages.json", JSON.stringify(messages))
 
 			const getMessages = async (customFs: NodeishFilesystemSubset) => {
@@ -1121,9 +1121,11 @@ describe("functionality", () => {
 			})
 
 			let counter = 0
+			let messageCount = 0
 
-			project.query.messages.getAll.subscribe(() => {
+			project.query.messages.getAll.subscribe((messages) => {
 				counter = counter + 1
+				messageCount = messages.length
 			})
 
 			// subscribe fires once
@@ -1135,6 +1137,7 @@ describe("functionality", () => {
 
 			// we didn't change the message we write into message.json - shouldn't change the messages
 			expect(counter).toBe(1)
+			expect(messageCount).toBe(1)
 
 			// saving the file without changing should trigger a change
 			messages.data[0]!.variants[0]!.pattern[0]!.value = "changed"
@@ -1142,14 +1145,32 @@ describe("functionality", () => {
 			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)
+			expect(messageCount).toBe(1)
 
 			messages.data[0]!.variants[0]!.pattern[0]!.value = "changed3"
 
-			// change file
+			// change file - update message
 			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(3)
+			expect(messageCount).toBe(1)
+
+			// change file - add a message
+			messages.data.push(newMessage)
+			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(4)
+			expect(messageCount).toBe(2)
+
+			// change file - remove a message
+			messages.data.pop()
+			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(5)
+			expect(messageCount).toBe(1)
 		})
 	})
 })

package/src/loadProject.ts

@@ -12,7 +12,7 @@ import {
 	ProjectSettingsFileNotFoundError,
 	ProjectSettingsInvalidError,
 } from "./errors.js"
-import { createRoot, createSignal, createEffect } from "./reactivity/solid.js"
+import { createRoot, createSignal, createEffect, batch } from "./reactivity/solid.js"
 import { createMessagesQuery } from "./createMessagesQuery.js"
 import { createMessageLintReportsQuery } from "./createMessageLintReportsQuery.js"
 import { ProjectSettings, type NodeishFilesystemSubset } from "./versionedInterfaces.js"
@@ -111,7 +111,12 @@ export async function loadProject(args: {
 						pathPattern: projectPath + "/messages.json",
 					}
 				}
-				_setSettings(validatedSettings)
+
+				batch(() => {
+					// reset the resolved modules first - since they are no longer valid at that point
+					setResolvedModules(undefined)
+					_setSettings(validatedSettings)
+				})
 
 				writeSettingsToDisk(validatedSettings)
 				return { data: undefined }

package/src/reactivity/solid.test.ts

@@ -1,5 +1,13 @@
 import { describe, it, expect } from "vitest"
-import { createRoot, createSignal, createEffect, createMemo, createResource } from "./solid.js"
+import {
+	createRoot,
+	createSignal,
+	createEffect,
+	createMemo,
+	createResource,
+	untrack,
+} from "./solid.js"
+import { ReactiveMap } from "./map.js"
 
 function sleep(ms: number) {
 	return new Promise((resolve) => setTimeout(resolve, ms))
@@ -174,3 +182,48 @@ describe("solid", () => {
 		expect(memo()).toBe("memo = 2000")
 	})
 })
+
+describe("solid", () => {
+	it("solid reactive map allows to use untrack", () => {
+		// @ts-expect-error -- ReactiveMap seem to have problems type arguments here
+		const reactiveMap = new ReactiveMap<string, any>()
+		const [plainSignal, setPlainSignal] = createSignal(0)
+
+		let shouldTriggerOnBoth = -1
+		createEffect(() => {
+			shouldTriggerOnBoth++
+			reactiveMap.values()
+			plainSignal()
+		})
+
+		let shouldTriggerOnReactiveMapOnly = -1
+		createEffect(() => {
+			shouldTriggerOnReactiveMapOnly++
+			reactiveMap.values()
+			untrack(() => plainSignal())
+		})
+
+		let shouldTriggerOnPlainSignalOnly = -1
+		createEffect(() => {
+			shouldTriggerOnPlainSignalOnly++
+			untrack(() => reactiveMap.values())
+			plainSignal()
+		})
+
+		expect(shouldTriggerOnBoth).toBe(0)
+		expect(shouldTriggerOnReactiveMapOnly).toBe(0)
+		expect(shouldTriggerOnPlainSignalOnly).toBe(0)
+
+		setPlainSignal(1)
+
+		expect(shouldTriggerOnBoth).toBe(1)
+		expect(shouldTriggerOnReactiveMapOnly).toBe(0)
+		expect(shouldTriggerOnPlainSignalOnly).toBe(1)
+
+		reactiveMap.set("a", "a")
+
+		expect(shouldTriggerOnBoth).toBe(2)
+		expect(shouldTriggerOnReactiveMapOnly).toBe(1)
+		expect(shouldTriggerOnPlainSignalOnly).toBe(1)
+	})
+})

package/src/reactivity/solid.ts

@@ -4,6 +4,7 @@ import {
 	createRoot as _createRoot,
 	createEffect as _createEffect,
 	createResource as _createResource,
+	untrack as _untrack,
 	observable as _observable,
 	batch as _batch,
 	from as _from,
@@ -23,6 +24,7 @@ const from = _from as typeof import("solid-js")["from"]
 const batch = _batch as typeof import("solid-js")["batch"]
 const getListener = _getListener as typeof import("solid-js")["getListener"]
 const onCleanup = _onCleanup as typeof import("solid-js")["onCleanup"]
+const untrack = _untrack as typeof import("solid-js")["untrack"]
 
 export {
 	createSignal,
@@ -35,5 +37,6 @@ export {
 	batch,
 	getListener,
 	onCleanup,
+	untrack,
 	DEV,
 }

package/src/v2/createMessageBundle.test.ts

@@ -0,0 +1,95 @@
+import { describe, it, expect } from "vitest"
+import { createMessageBundle, createMessage } from "./createMessageBundle.js"
+import { MessageBundle } from "./types.js"
+import { Value } from "@sinclair/typebox/value"
+
+describe("createMessageBundle", () => {
+	it("creates a bundle with no messages", () => {
+		const bundle: unknown = createMessageBundle({ id: "no_messages", messages: [] })
+		expect(Value.Check(MessageBundle, bundle)).toBe(true)
+		expect(bundle).toEqual({
+			id: "no_messages",
+			alias: {},
+			messages: [],
+		} satisfies MessageBundle)
+	})
+
+	it("creates a bundle with a single text-only message", () => {
+		const bundle: unknown = createMessageBundle({
+			id: "hello_world",
+			messages: [createMessage({ locale: "en", text: "Hello World!" })],
+		})
+		expect(Value.Check(MessageBundle, bundle)).toBe(true)
+		expect(bundle).toEqual({
+			id: "hello_world",
+			alias: {},
+			messages: [
+				{
+					locale: "en",
+					declarations: [],
+					selectors: [],
+					variants: [
+						{
+							match: [],
+							pattern: [
+								{
+									type: "text",
+									value: "Hello World!",
+								},
+							],
+						},
+					],
+				},
+			],
+		} satisfies MessageBundle)
+	})
+
+	it("creates a bundle with multiple text-only messages", () => {
+		const bundle: unknown = createMessageBundle({
+			id: "hello_world_2",
+			messages: [
+				createMessage({ locale: "en", text: "Hello World!" }),
+				createMessage({ locale: "de", text: "Hallo Welt!" }),
+			],
+		})
+		expect(Value.Check(MessageBundle, bundle)).toBe(true)
+		expect(bundle).toEqual({
+			id: "hello_world_2",
+			alias: {},
+			messages: [
+				{
+					locale: "en",
+					declarations: [],
+					selectors: [],
+					variants: [
+						{
+							match: [],
+							pattern: [
+								{
+									type: "text",
+									value: "Hello World!",
+								},
+							],
+						},
+					],
+				},
+				{
+					locale: "de",
+					declarations: [],
+					selectors: [],
+					variants: [
+						{
+							match: [],
+							pattern: [
+								{
+									type: "text",
+									value: "Hallo Welt!",
+								},
+							],
+						},
+					],
+				},
+			],
+		} satisfies MessageBundle)
+	})
+})

package/src/v2/createMessageBundle.ts

@@ -0,0 +1,43 @@
+import { LanguageTag, MessageBundle, Message, Text } from "./types.js"
+
+/**
+ * create v2 MessageBundle
+ * @example createMessageBundle({
+ * 	 id: "greeting",
+ *   messages: [
+ * 		 createMessage({locale: "en", text: "Hello world!"})
+ * 		 createMessage({locale: "de", text: "Hallo Welt!"})
+ *   ]
+ * })
+ */
+export function createMessageBundle(args: {
+	id: string
+	messages: Message[]
+	alias?: MessageBundle["alias"]
+}): MessageBundle {
+	return {
+		id: args.id,
+		alias: args.alias ?? {},
+		messages: args.messages,
+	}
+}
+
+/**
+ * create v2 Messsage AST with text-only pattern
+ * @example createMessage({locale: "en", text: "Hello world"})
+ */
+export function createMessage(args: { locale: LanguageTag; text: string }): Message {
+	return {
+		locale: args.locale,
+		declarations: [],
+		selectors: [],
+		variants: [{ match: [], pattern: [toTextElement(args.text ?? "")] }],
+	}
+}
+
+function toTextElement(text: string): Text {
+	return {
+		type: "text",
+		value: text,
+	}
+}

package/src/v2/mocks/plural/bundle.test.ts

@@ -0,0 +1,18 @@
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+
+import { describe, it, expect } from "vitest"
+import { bundle } from "./bundle.js"
+import { MessageBundle } from "../../types.js"
+import { Value } from "@sinclair/typebox/value"
+
+describe("mock plural messageBundle", () => {
+	it("is valid", () => {
+		const messageBundle: unknown = bundle
+		expect(Value.Check(MessageBundle, messageBundle)).toBe(true)
+
+		expect(bundle.messages.length).toBe(2)
+		expect(bundle.messages[0]!.declarations.length).toBe(1)
+		expect(bundle.messages[0]!.selectors.length).toBe(1)
+		expect(bundle.messages[0]!.variants.length).toBe(3)
+	})
+})

package/src/v2/mocks/plural/bundle.ts

@@ -0,0 +1,142 @@
+import type { MessageBundle } from "../../types.js"
+
+export const bundle: MessageBundle = {
+	id: "mock_bundle_human_id",
+	alias: {
+		default: "mock_bundle_alias",
+	},
+	messages: [
+		{
+			locale: "de",
+			declarations: [
+				{
+					type: "input",
+					name: "numProducts",
+					value: {
+						type: "expression",
+						arg: {
+							type: "variable",
+							name: "numProducts",
+						},
+					},
+				},
+			],
+			selectors: [
+				{
+					type: "expression",
+					arg: {
+						type: "variable",
+						name: "numProducts",
+					},
+					annotation: {
+						type: "function",
+						name: "plural",
+						options: [],
+					},
+				},
+			],
+			variants: [
+				{
+					match: ["zero"],
+					pattern: [
+						{
+							type: "text",
+							value: "Keine Produkte",
+						},
+					],
+				},
+				{
+					match: ["one"],
+					pattern: [
+						{
+							type: "text",
+							value: "Ein Produkt",
+						},
+					],
+				},
+				{
+					match: ["other"],
+					pattern: [
+						{
+							type: "expression",
+							arg: {
+								type: "variable",
+								name: "numProducts",
+							},
+						},
+						{
+							type: "text",
+							value: " Produkte",
+						},
+					],
+				},
+			],
+		},
+		{
+			locale: "en",
+			declarations: [
+				{
+					type: "input",
+					name: "numProducts",
+					value: {
+						type: "expression",
+						arg: {
+							type: "variable",
+							name: "numProducts",
+						},
+					},
+				},
+			],
+			selectors: [
+				{
+					type: "expression",
+					arg: {
+						type: "variable",
+						name: "numProducts",
+					},
+					annotation: {
+						type: "function",
+						name: "plural",
+						options: [],
+					},
+				},
+			],
+			variants: [
+				{
+					match: ["zero"],
+					pattern: [
+						{
+							type: "text",
+							value: "No Products",
+						},
+					],
+				},
+				{
+					match: ["one"],
+					pattern: [
+						{
+							type: "text",
+							value: "A product",
+						},
+					],
+				},
+				{
+					match: ["other"],
+					pattern: [
+						{
+							type: "expression",
+							arg: {
+								type: "variable",
+								name: "numProducts",
+							},
+						},
+						{
+							type: "text",
+							value: " products",
+						},
+					],
+				},
+			],
+		},
+	],
+}