@inlang/sdk 0.34.8 → 0.34.10

package/src/createMessagesQuery.ts

@@ -1,13 +1,12 @@
 import type { Message } from "@inlang/message"
 import { ReactiveMap } from "./reactivity/map.js"
-import { createEffect } from "./reactivity/solid.js"
+import { createEffect, onCleanup } from "./reactivity/solid.js"
 import { createSubscribable } from "./loadProject.js"
 import type { InlangProject, MessageQueryApi, MessageQueryDelegate } from "./api.js"
 import type { ResolvedPluginApi } from "./resolve-modules/plugins/types.js"
 import type { resolveModules } from "./resolve-modules/resolveModules.js"
 import { createNodeishFsWithWatcher } from "./createNodeishFsWithWatcher.js"
 import type { NodeishFilesystem } from "@lix-js/fs"
-import { onCleanup } from "solid-js"
 import { stringifyMessage } from "./storage/helper.js"
 import { acquireFileLock } from "./persistence/filelock/acquireFileLock.js"
 import _debug from "debug"
@@ -15,7 +14,7 @@ import type { ProjectSettings } from "@inlang/project-settings"
 import { releaseLock } from "./persistence/filelock/releaseLock.js"
 import { PluginLoadMessagesError, PluginSaveMessagesError } from "./errors.js"
 import { humanIdHash } from "./storage/human-id/human-readable-id.js"
-const debug = _debug("sdk:createMessagesQuery")
+const debug = _debug("sdk:messages")
 
 function sleep(ms: number) {
 	return new Promise((resolve) => setTimeout(resolve, ms))
@@ -62,14 +61,18 @@ export function createMessagesQuery({
 }: createMessagesQueryParameters): InlangProject["query"]["messages"] {
 	// @ts-expect-error
 	const index = new ReactiveMap<string, Message>()
+	let loaded = false
 
 	// filepath for the lock folder
 	const messageLockDirPath = projectPath + "/messagelock"
 
 	let delegate: MessageQueryDelegate | undefined = undefined
 
-	const setDelegate = (newDelegate: MessageQueryDelegate) => {
+	const setDelegate = (newDelegate: MessageQueryDelegate | undefined, onLoad: boolean) => {
 		delegate = newDelegate
+		if (newDelegate && loaded && onLoad) {
+			newDelegate.onLoaded([...index.values()] as Message[])
+		}
 	}
 
 	// Map default alias to message
@@ -94,6 +97,7 @@ export function createMessagesQuery({
 		// we clear the index independent from the change for
 		index.clear()
 		defaultAliasIndex.clear()
+		loaded = false
 
 		// Load messages -> use settings to subscribe to signals from the settings
 		const _settings = settings()
@@ -143,7 +147,7 @@ export function createMessagesQuery({
 			messageLockDirPath,
 			messageStates,
 			index,
-			delegate,
+			undefined /* delegate - we don't pass it here since we will call onLoaded instead */,
 			_settings, // NOTE we bang here - we don't expect the settings to become null during the livetime of a project
 			resolvedPluginApi
 		)
@@ -154,6 +158,7 @@ export function createMessagesQuery({
 			.then(() => {
 				onInitialMessageLoadResult()
 				delegate?.onLoaded([...index.values()])
+				loaded = true
 			})
 	})
 
@@ -203,7 +208,7 @@ export function createMessagesQuery({
 			}
 
 			messageStates.messageDirtyFlags[data.id] = true
-			delegate?.onMessageCreate(data.id, index.get(data.id))
+			delegate?.onMessageCreate(data.id, index.get(data.id), [...index.values()])
 			scheduleSave()
 			return true
 		},
@@ -230,7 +235,7 @@ export function createMessagesQuery({
 			if (message === undefined) return false
 			index.set(where.id, { ...message, ...data })
 			messageStates.messageDirtyFlags[where.id] = true
-			delegate?.onMessageCreate(where.id, index.get(data.id))
+			delegate?.onMessageUpdate(where.id, index.get(data.id), [...index.values()])
 			scheduleSave()
 			return true
 		},
@@ -242,11 +247,11 @@ export function createMessagesQuery({
 					defaultAliasIndex.set(data.alias.default, data)
 				}
 				messageStates.messageDirtyFlags[where.id] = true
-				delegate?.onMessageCreate(data.id, index.get(data.id))
+				delegate?.onMessageCreate(data.id, index.get(data.id), [...index.values()])
 			} else {
 				index.set(where.id, { ...message, ...data })
 				messageStates.messageDirtyFlags[where.id] = true
-				delegate?.onMessageUpdate(data.id, index.get(data.id))
+				delegate?.onMessageUpdate(data.id, index.get(data.id), [...index.values()])
 			}
 			scheduleSave()
 			return true
@@ -259,7 +264,7 @@ export function createMessagesQuery({
 			}
 			index.delete(where.id)
 			messageStates.messageDirtyFlags[where.id] = true
-			delegate?.onMessageDelete(where.id)
+			delegate?.onMessageDelete(where.id, [...index.values()])
 			scheduleSave()
 			return true
 		},
@@ -323,6 +328,8 @@ async function loadMessagesViaPlugin(
 
 		let loadedMessageCount = 0
 
+		const deletedMessages = new Set(messages.keys())
+
 		for (const loadedMessage of loadedMessages) {
 			const loadedMessageClone = structuredClone(loadedMessage)
 
@@ -338,6 +345,8 @@ async function loadMessagesViaPlugin(
 				// - this could be the case if one edits the aliase manualy
 				throw new Error("more than one message with the same id or alias found ")
 			} else if (currentMessages.length === 1) {
+				// eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- length has checked beforhand
+				deletedMessages.delete(currentMessages[0]!.id)
 				// update message in place - leave message id and alias untouched
 				loadedMessageClone.alias = {} as any
 
@@ -364,7 +373,7 @@ async function loadMessagesViaPlugin(
 				messages.set(loadedMessageClone.id, loadedMessageClone)
 				// NOTE could use hash instead of the whole object JSON to save memory...
 				messageState.messageLoadHash[loadedMessageClone.id] = importedEnecoded
-				delegate?.onMessageUpdate(loadedMessageClone.id, loadedMessageClone)
+				delegate?.onMessageUpdate(loadedMessageClone.id, loadedMessageClone, [...messages.values()])
 				loadedMessageCount++
 			} else {
 				// message with the given alias does not exist so far
@@ -392,7 +401,7 @@ async function loadMessagesViaPlugin(
 				// we don't have to check - done before hand if (messages.has(loadedMessageClone.id)) return false
 				messages.set(loadedMessageClone.id, loadedMessageClone)
 				messageState.messageLoadHash[loadedMessageClone.id] = importedEnecoded
-				delegate?.onMessageUpdate(loadedMessageClone.id, loadedMessageClone)
+				delegate?.onMessageUpdate(loadedMessageClone.id, loadedMessageClone, [...messages.values()])
 				loadedMessageCount++
 			}
 			if (loadedMessageCount > maxMessagesPerTick) {
@@ -403,6 +412,18 @@ async function loadMessagesViaPlugin(
 				loadedMessageCount = 0
 			}
 		}
+
+		loadedMessageCount = 0
+		for (const deletedMessageId of deletedMessages) {
+			messages.delete(deletedMessageId)
+			delegate?.onMessageDelete(deletedMessageId, [...messages.values()])
+			loadedMessageCount++
+			if (loadedMessageCount > maxMessagesPerTick) {
+				await sleep(0)
+				loadedMessageCount = 0
+			}
+		}
+
 		await releaseLock(fs as NodeishFilesystem, lockDirPath, "loadMessage", lockTime)
 		lockTime = undefined
 

package/src/createNewProject.ts

@@ -6,11 +6,6 @@ import { defaultProjectSettings } from "./defaultProjectSettings.js"
 /**
  * Creates a new project in the given directory.
  * The directory must be an absolute path, must not exist, and must end with {name}.inlang
- * Uses defaultProjectSettings unless projectSettings are provided.
- *
- * @param projectPath - Absolute path to the [name].inlang directory
- * @param repo - An instance of a lix repo as returned by `openRepository`
- * @param projectSettings - Optional project settings to use for the new project.
  */
 export async function createNewProject(args: {
 	projectPath: string

package/src/createNodeishFsWithWatcher.ts

@@ -20,7 +20,7 @@ export const createNodeishFsWithWatcher = (args: {
 			ac.abort()
 		}
 		// release references
-		abortControllers = [];
+		abortControllers = []
 	}
 
 	const makeWatcher = (path: string) => {

package/src/lint/message/lintSingleMessage.ts

@@ -50,5 +50,8 @@ export const lintSingleMessage = async (args: {
 
 	await Promise.all(promises)
 
-	return { data: reports, errors }
+	// we sort the reports by rule id to allow us to easyly compare both
+	const sortedReports = reports.sort((r1, r2) => r1.ruleId.localeCompare(r2.ruleId))
+
+	return { data: sortedReports, errors }
 }

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/persistence/filelock/acquireFileLock.ts

@@ -1,7 +1,7 @@
 import { type NodeishFilesystem } from "@lix-js/fs"
 import type { NodeishStats } from "@lix-js/fs"
 import _debug from "debug"
-const debug = _debug("sdk:acquireFileLock")
+const debug = _debug("sdk:fileLock")
 
 const maxRetries = 10
 const nProbes = 50
@@ -13,7 +13,9 @@ export async function acquireFileLock(
 	tryCount: number = 0
 ): Promise<number> {
 	if (tryCount > maxRetries) {
-		throw new Error(lockOrigin + " exceeded maximum Retries (5) to acquire lockfile " + tryCount)
+		throw new Error(
+			`${lockOrigin} exceeded maximum retries (${maxRetries}) to acquire lockfile ${tryCount}`
+		)
 	}
 
 	try {

package/src/persistence/filelock/releaseLock.ts

@@ -1,6 +1,6 @@
 import { type NodeishFilesystem } from "@lix-js/fs"
 import _debug from "debug"
-const debug = _debug("sdk:releaseLock")
+const debug = _debug("sdk:fileLock")
 
 export async function releaseLock(
 	fs: NodeishFilesystem,

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)
+	})
+})