@inlang/sdk 0.35.4 → 0.35.6

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

@@ -1,6 +1,6 @@
 import type { MessageBundle } from "../../types.js"
 
-export const bundle: MessageBundle = {
+export const pluralBundle: MessageBundle = {
 	id: "mock_bundle_human_id",
 	alias: {
 		default: "mock_bundle_alias",

package/src/v2/shim.test.ts

@@ -0,0 +1,56 @@
+import { test, expect } from "vitest"
+import * as V2 from "./types.js"
+import * as V1 from "@inlang/message"
+import { createMessageBundle, createMessage } from "./helper.js"
+import { toV1Message, fromV1Message } from "./shim.js"
+import { Value } from "@sinclair/typebox/value"
+
+const bundle = createMessageBundle({
+	id: "hello_world",
+	messages: [
+		createMessage({ locale: "en", text: "Hello World!" }),
+		createMessage({ locale: "de", text: "Hallo Welt!" }),
+	],
+})
+
+test("toV1Message and fromV1Message", () => {
+	expect(Value.Check(V2.MessageBundle, bundle)).toBe(true)
+
+	const v1Message: unknown = toV1Message(bundle)
+	expect(Value.Check(V1.Message, v1Message)).toBe(true)
+
+	expect(v1Message).toEqual({
+		id: "hello_world",
+		alias: {},
+		variants: [
+			{
+				languageTag: "en",
+				match: [],
+				pattern: [
+					{
+						type: "Text",
+						value: "Hello World!",
+					},
+				],
+			},
+			{
+				languageTag: "de",
+				match: [],
+				pattern: [
+					{
+						type: "Text",
+						value: "Hallo Welt!",
+					},
+				],
+			},
+		],
+		selectors: [],
+	})
+
+	const v2MessageBundle: unknown = fromV1Message(v1Message as V1.Message)
+	expect(Value.Check(V2.MessageBundle, v2MessageBundle)).toBe(true)
+
+	expect(v2MessageBundle).toEqual(bundle)
+})
+
+test.todo("with variable references", () => {})

package/src/v2/shim.ts

@@ -0,0 +1,173 @@
+/**
+ * Convert between v1 Message and v2 MessageBundle formats.
+ * Code adapted from https://github.com/opral/monorepo/pull/2655 legacy.ts
+ */
+
+import * as V2 from "./types.js"
+import * as V1 from "@inlang/message"
+
+/**
+ * @throws If the message cannot be represented in the v1 format
+ */
+export function toV1Message(bundle: V2.MessageBundle): V1.Message {
+	const variants: V1.Variant[] = []
+	const selectorNames = new Set<string>()
+
+	for (const message of bundle.messages) {
+		// collect all selector names
+		for (const selector of message.selectors.map(toV1Expression)) {
+			selectorNames.add(selector.name)
+		}
+
+		// collect all variants
+		for (const variant of message.variants) {
+			variants.push({
+				languageTag: message.locale,
+				match: variant.match,
+				pattern: toV1Pattern(variant.pattern),
+			})
+		}
+	}
+
+	const selectors: V1.Expression[] = [...selectorNames].map((name) => ({
+		type: "VariableReference",
+		name,
+	}))
+
+	return {
+		id: bundle.id,
+		alias: bundle.alias,
+		variants,
+		selectors,
+	}
+}
+
+/**
+ * @throws If the pattern cannot be represented in the v1 format
+ */
+function toV1Pattern(pattern: V2.Pattern): V1.Pattern {
+	return pattern.map((element) => {
+		switch (element.type) {
+			case "text": {
+				return {
+					type: "Text",
+					value: element.value,
+				}
+			}
+
+			case "expression": {
+				return toV1Expression(element)
+			}
+
+			default: {
+				throw new Error(`Unsupported pattern element type`)
+			}
+		}
+	})
+}
+
+function toV1Expression(expression: V2.Expression): V1.Expression {
+	if (expression.annotation !== undefined)
+		throw new Error("Cannot convert an expression with an annotation to the v1 format")
+
+	if (expression.arg.type !== "variable") {
+		throw new Error("Can only convert variable references to the v1 format")
+	}
+
+	return {
+		type: "VariableReference",
+		name: expression.arg.name,
+	}
+}
+
+export function fromV1Message(v1Message: V1.Message): V2.MessageBundle {
+	const languages = dedup(v1Message.variants.map((variant) => variant.languageTag))
+
+	const messages: V2.Message[] = languages.map((language): V2.Message => {
+		//All variants that will be part of this message
+		const v1Variants = v1Message.variants.filter((variant) => variant.languageTag === language)
+
+		//find all selector names
+		const selectorNames = new Set<string>()
+		for (const v1Selector of v1Message.selectors) {
+			selectorNames.add(v1Selector.name)
+		}
+		const selectors: V2.Expression[] = [...selectorNames].map((name) => ({
+			type: "expression",
+			annotation: undefined,
+			arg: {
+				type: "variable",
+				name: name,
+			},
+		}))
+
+		//The set of variables that need to be defined - Certainly includes the selectors
+		const variableNames = new Set<string>(selectorNames)
+		const variants: V2.Variant[] = []
+		for (const v1Variant of v1Variants) {
+			for (const element of v1Variant.pattern) {
+				if (element.type === "VariableReference") {
+					variableNames.add(element.name)
+				}
+			}
+
+			variants.push({
+				match: v1Variant.match,
+				pattern: fromV1Pattern(v1Variant.pattern),
+			})
+		}
+
+		//Create an input declaration for each variable and selector we need
+		const declarations: V2.Declaration[] = [...variableNames].map((name) => ({
+			type: "input",
+			name,
+			value: {
+				type: "expression",
+				annotation: undefined,
+				arg: {
+					type: "variable",
+					name,
+				},
+			},
+		}))
+
+		return {
+			locale: language,
+			declarations,
+			selectors,
+			variants,
+		}
+	})
+
+	return {
+		id: v1Message.id,
+		alias: v1Message.alias,
+		messages,
+	}
+}
+
+function fromV1Pattern(pattern: V1.Pattern): V2.Pattern {
+	return pattern.map((element) => {
+		switch (element.type) {
+			case "Text": {
+				return {
+					type: "text",
+					value: element.value,
+				}
+			}
+			case "VariableReference":
+				return {
+					type: "expression",
+					arg: {
+						type: "variable",
+						name: element.name,
+					},
+				}
+		}
+	})
+}
+
+/**
+ * Dedups an array by converting it to a set and back
+ */
+const dedup = <T extends Array<unknown>>(arr: T): T => [...new Set(arr)] as T

package/src/v2/stubQueryApi.ts

@@ -0,0 +1,43 @@
+import type { MessageQueryApi, MessageLintReportsQueryApi } from "../api.js"
+
+/**
+ * noop implementation of the message query api for use with experimental.persistence = true.
+ * NOTE: If we implemented v2 shims for the old api we could use existing tests and make apps
+ * backwards compatible.
+ */
+export const stubMessagesQuery: MessageQueryApi = {
+	create: () => false,
+	// @ts-expect-error
+	get: subscribable(() => undefined),
+	// @ts-expect-error
+	getByDefaultAlias: subscribable(() => undefined),
+	// @ts-expect-error
+	includedMessageIds: subscribable(() => []),
+	// @ts-expect-error
+	getAll: subscribable(() => []),
+	update: () => false,
+	upsert: () => {},
+	delete: () => false,
+	setDelegate: () => {},
+}
+
+export const stubMessageLintReportsQuery: MessageLintReportsQueryApi = {
+	// @ts-expect-error
+	get: subscribable(() => []),
+	// @ts-expect-error
+	getAll: settleable(subscribable(() => [])),
+}
+
+// eslint-disable-next-line @typescript-eslint/ban-types
+function subscribable(fn: Function) {
+	return Object.assign(fn, {
+		subscribe: () => {},
+	})
+}
+
+// eslint-disable-next-line @typescript-eslint/ban-types
+function settleable(fn: Function) {
+	return Object.assign(fn, {
+		settled: async () => {},
+	})
+}

package/src/v2/types.ts

@@ -140,3 +140,20 @@ export const MessageBundle = Type.Object({
 	alias: Type.Record(Type.String(), Type.String()),
 	messages: Type.Array(Message),
 })
+
+/**
+ * A MessageSlot is a placeholder for a message with a locale.
+ * This is useful to avoid merge conflicts when translations are added.
+ */
+export type MessageSlot = Static<typeof MessageSlot>
+export const MessageSlot = Type.Object({
+	locale: LanguageTag,
+	slot: Type.Literal(true),
+})
+
+export type MessageBundleWithSlots = Static<typeof MessageBundleWithSlots>
+export const MessageBundleWithSlots = Type.Object({
+	id: Type.String(),
+	alias: Type.Record(Type.String(), Type.String()),
+	messages: Type.Array(Type.Union([Message, MessageSlot])),
+})

package/dist/persistence/plugin.d.ts

@@ -1,31 +0,0 @@
-import type { ProjectSettings, Message } from "@inlang/sdk";
-import { type NodeishFilesystem } from "@lix-js/fs";
-export declare const pluginId = "plugin.sdk.persistence";
-export declare function loadMessages(args: {
-    settings: ProjectSettings;
-    nodeishFs: NodeishFilesystem;
-}): Promise<{
-    id: string;
-    alias: Record<string, string>;
-    selectors: {
-        type: "VariableReference";
-        name: string;
-    }[];
-    variants: {
-        languageTag: string;
-        match: string[];
-        pattern: ({
-            type: "Text";
-            value: string;
-        } | {
-            type: "VariableReference";
-            name: string;
-        })[];
-    }[];
-}[]>;
-export declare function saveMessages(args: {
-    settings: ProjectSettings;
-    nodeishFs: NodeishFilesystem;
-    messages: Message[];
-}): Promise<void>;
-//# sourceMappingURL=plugin.d.ts.map

package/dist/persistence/plugin.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../../src/persistence/plugin.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,OAAO,EAAE,MAAM,aAAa,CAAA;AAC3D,OAAO,EAAc,KAAK,iBAAiB,EAAE,MAAM,YAAY,CAAA;AAM/D,eAAO,MAAM,QAAQ,2BAA2B,CAAA;AAEhD,wBAAsB,YAAY,CAAC,IAAI,EAAE;IACxC,QAAQ,EAAE,eAAe,CAAA;IACzB,SAAS,EAAE,iBAAiB,CAAA;CAC5B;;;;;;;;;;;;;;;;;;KAeA;AAED,wBAAsB,YAAY,CAAC,IAAI,EAAE;IACxC,QAAQ,EAAE,eAAe,CAAA;IACzB,SAAS,EAAE,iBAAiB,CAAA;IAC5B,QAAQ,EAAE,OAAO,EAAE,CAAA;CACnB,iBAcA"}

package/dist/persistence/plugin.js

@@ -1,42 +0,0 @@
-import { getDirname } from "@lix-js/fs";
-import { normalizeMessage } from "../storage/helper.js";
-import _debug from "debug";
-const debug = _debug("sdk:persistence");
-export const pluginId = "plugin.sdk.persistence";
-export async function loadMessages(args) {
-    let result = [];
-    const pathPattern = args.settings[pluginId]?.pathPattern;
-    debug("loadMessages", pathPattern);
-    try {
-        const file = await args.nodeishFs.readFile(pathPattern, { encoding: "utf-8" });
-        result = JSON.parse(file);
-    }
-    catch (error) {
-        if (error?.code !== "ENOENT") {
-            debug("loadMessages", error);
-            throw error;
-        }
-    }
-    return result;
-}
-export async function saveMessages(args) {
-    const pathPattern = args.settings[pluginId]?.pathPattern;
-    debug("saveMessages", pathPattern);
-    try {
-        await createDirectoryIfNotExits(getDirname(pathPattern), args.nodeishFs);
-        await args.nodeishFs.writeFile(pathPattern, 
-        // 2 spaces indentation
-        JSON.stringify(args.messages.map(normalizeMessage), undefined, 2));
-    }
-    catch (error) {
-        debug("saveMessages", error);
-    }
-}
-async function createDirectoryIfNotExits(path, nodeishFs) {
-    try {
-        await nodeishFs.mkdir(path, { recursive: true });
-    }
-    catch {
-        // assume that the directory already exists
-    }
-}

package/dist/persistence/plugin.test.d.ts

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

package/dist/persistence/plugin.test.d.ts.map

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

package/dist/persistence/plugin.test.js

@@ -1,49 +0,0 @@
-import { test, expect } from "vitest";
-import { createMessage, createNodeishMemoryFs } from "../test-utilities/index.js";
-import { normalizeMessage } from "../storage/helper.js";
-import { pluginId } from "./plugin.js";
-const mockMessages = [
-    createMessage("first_message", {
-        en: "If this fails I will be sad",
-    }),
-    createMessage("second_message", {
-        en: "Let's see if this works",
-        de: "Mal sehen ob das funktioniert",
-    }),
-];
-// the test ensures:
-//   - messages can be loaded
-//   - messages can be saved
-//   - after loading and saving messages, the state is the same as before (roundtrip)
-test("roundtrip (saving/loading messages)", async () => {
-    const { loadMessages, saveMessages } = await import("./plugin.js");
-    const fs = createNodeishMemoryFs();
-    const projectDir = "/test/project.inlang";
-    const pathPattern = projectDir + "/messages.json";
-    const persistedMessages = JSON.stringify(mockMessages.map(normalizeMessage), undefined, 2);
-    const settings = {
-        sourceLanguageTag: "en",
-        languageTags: ["en", "de"],
-        modules: [],
-        [pluginId]: { pathPattern },
-    };
-    await fs.mkdir(projectDir, { recursive: true });
-    await fs.writeFile(pathPattern, persistedMessages);
-    const firstMessageLoad = await loadMessages({
-        settings,
-        nodeishFs: fs,
-    });
-    expect(firstMessageLoad).toStrictEqual(mockMessages);
-    await saveMessages({
-        settings,
-        nodeishFs: fs,
-        messages: firstMessageLoad,
-    });
-    const afterRoundtrip = await fs.readFile(pathPattern, { encoding: "utf-8" });
-    expect(afterRoundtrip).toStrictEqual(persistedMessages);
-    const messagesAfterRoundtrip = await loadMessages({
-        settings,
-        nodeishFs: fs,
-    });
-    expect(messagesAfterRoundtrip).toStrictEqual(firstMessageLoad);
-});

package/dist/v2/createMessageBundle.d.ts

@@ -1,25 +0,0 @@
-import { LanguageTag, MessageBundle, Message } from "./types.js";
-/**
- * create v2 MessageBundle
- * @example createMessageBundle({
- * 	 id: "greeting",
- *   messages: [
- * 		 createMessage({locale: "en", text: "Hello world!"})
- * 		 createMessage({locale: "de", text: "Hallo Welt!"})
- *   ]
- * })
- */
-export declare function createMessageBundle(args: {
-    id: string;
-    messages: Message[];
-    alias?: MessageBundle["alias"];
-}): MessageBundle;
-/**
- * create v2 Messsage AST with text-only pattern
- * @example createMessage({locale: "en", text: "Hello world"})
- */
-export declare function createMessage(args: {
-    locale: LanguageTag;
-    text: string;
-}): Message;
-//# sourceMappingURL=createMessageBundle.d.ts.map

package/dist/v2/createMessageBundle.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"createMessageBundle.d.ts","sourceRoot":"","sources":["../../src/v2/createMessageBundle.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,aAAa,EAAE,OAAO,EAAQ,MAAM,YAAY,CAAA;AAEtE;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE;IACzC,EAAE,EAAE,MAAM,CAAA;IACV,QAAQ,EAAE,OAAO,EAAE,CAAA;IACnB,KAAK,CAAC,EAAE,aAAa,CAAC,OAAO,CAAC,CAAA;CAC9B,GAAG,aAAa,CAMhB;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE;IAAE,MAAM,EAAE,WAAW,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG,OAAO,CAOlF"}

package/dist/v2/createMessageBundle.js

@@ -1,36 +0,0 @@
-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) {
-    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) {
-    return {
-        locale: args.locale,
-        declarations: [],
-        selectors: [],
-        variants: [{ match: [], pattern: [toTextElement(args.text ?? "")] }],
-    };
-}
-function toTextElement(text) {
-    return {
-        type: "text",
-        value: text,
-    };
-}

package/dist/v2/createMessageBundle.test.d.ts

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

package/dist/v2/createMessageBundle.test.d.ts.map

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

package/src/persistence/plugin.test.ts

@@ -1,60 +0,0 @@
-import { test, expect } from "vitest"
-import { createMessage, createNodeishMemoryFs } from "../test-utilities/index.js"
-import { normalizeMessage } from "../storage/helper.js"
-import { pluginId } from "./plugin.js"
-
-const mockMessages = [
-	createMessage("first_message", {
-		en: "If this fails I will be sad",
-	}),
-	createMessage("second_message", {
-		en: "Let's see if this works",
-		de: "Mal sehen ob das funktioniert",
-	}),
-]
-
-// the test ensures:
-//   - messages can be loaded
-//   - messages can be saved
-//   - after loading and saving messages, the state is the same as before (roundtrip)
-test("roundtrip (saving/loading messages)", async () => {
-	const { loadMessages, saveMessages } = await import("./plugin.js")
-	const fs = createNodeishMemoryFs()
-	const projectDir = "/test/project.inlang"
-	const pathPattern = projectDir + "/messages.json"
-	const persistedMessages = JSON.stringify(mockMessages.map(normalizeMessage), undefined, 2)
-
-	const settings = {
-		sourceLanguageTag: "en",
-		languageTags: ["en", "de"],
-		modules: [],
-		[pluginId]: { pathPattern },
-	}
-
-	await fs.mkdir(projectDir, { recursive: true })
-	await fs.writeFile(pathPattern, persistedMessages)
-
-	const firstMessageLoad = await loadMessages({
-		settings,
-		nodeishFs: fs,
-	})
-
-	expect(firstMessageLoad).toStrictEqual(mockMessages)
-
-	await saveMessages({
-		settings,
-		nodeishFs: fs,
-		messages: firstMessageLoad,
-	})
-
-	const afterRoundtrip = await fs.readFile(pathPattern, { encoding: "utf-8" })
-
-	expect(afterRoundtrip).toStrictEqual(persistedMessages)
-
-	const messagesAfterRoundtrip = await loadMessages({
-		settings,
-		nodeishFs: fs,
-	})
-
-	expect(messagesAfterRoundtrip).toStrictEqual(firstMessageLoad)
-})

package/src/persistence/plugin.ts

@@ -1,56 +0,0 @@
-import type { ProjectSettings, Message } from "@inlang/sdk"
-import { getDirname, type NodeishFilesystem } from "@lix-js/fs"
-import { normalizeMessage } from "../storage/helper.js"
-
-import _debug from "debug"
-const debug = _debug("sdk:persistence")
-
-export const pluginId = "plugin.sdk.persistence"
-
-export async function loadMessages(args: {
-	settings: ProjectSettings
-	nodeishFs: NodeishFilesystem
-}) {
-	let result: Message[] = []
-	const pathPattern = args.settings[pluginId]?.pathPattern as string
-
-	debug("loadMessages", pathPattern)
-	try {
-		const file = await args.nodeishFs.readFile(pathPattern, { encoding: "utf-8" })
-		result = JSON.parse(file)
-	} catch (error) {
-		if ((error as any)?.code !== "ENOENT") {
-			debug("loadMessages", error)
-			throw error
-		}
-	}
-	return result
-}
-
-export async function saveMessages(args: {
-	settings: ProjectSettings
-	nodeishFs: NodeishFilesystem
-	messages: Message[]
-}) {
-	const pathPattern = args.settings[pluginId]?.pathPattern as string
-
-	debug("saveMessages", pathPattern)
-	try {
-		await createDirectoryIfNotExits(getDirname(pathPattern), args.nodeishFs)
-		await args.nodeishFs.writeFile(
-			pathPattern,
-			// 2 spaces indentation
-			JSON.stringify(args.messages.map(normalizeMessage), undefined, 2)
-		)
-	} catch (error) {
-		debug("saveMessages", error)
-	}
-}
-
-async function createDirectoryIfNotExits(path: string, nodeishFs: NodeishFilesystem) {
-	try {
-		await nodeishFs.mkdir(path, { recursive: true })
-	} catch {
-		// assume that the directory already exists
-	}
-}

package/src/v2/createMessageBundle.ts

@@ -1,43 +0,0 @@
-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,
-	}
-}