@inlang/sdk 0.35.5 → 0.35.7

package/src/v2/helper.ts

@@ -0,0 +1,98 @@
+import {
+	LanguageTag,
+	MessageBundle,
+	MessageBundleWithSlots,
+	Message,
+	MessageSlot,
+	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
+	match?: Array<string>
+}): Message {
+	return {
+		locale: args.locale,
+		declarations: [],
+		selectors: [],
+		variants: [{ match: args.match ? args.match : [], pattern: [toTextElement(args.text ?? "")] }],
+	}
+}
+
+export function toTextElement(text: string): Text {
+	return {
+		type: "text",
+		value: text,
+	}
+}
+
+// ****************************
+// WIP experimental persistence
+// ****************************
+
+/**
+ * create MessageSlot for a locale (only used for persistence)
+ */
+export function createMessageSlot(locale: LanguageTag): MessageSlot {
+	return {
+		locale,
+		slot: true,
+	}
+}
+
+/**
+ * return structuredClone with message slots for all locales not yet present
+ */
+export function addSlots(messageBundle: MessageBundle, locales: string[]): MessageBundleWithSlots {
+	const bundle = structuredClone(messageBundle) as MessageBundleWithSlots
+	bundle.messages = locales.map((locale) => {
+		return bundle.messages.find((message) => message.locale === locale) ?? createMessageSlot(locale)
+	})
+	return bundle
+}
+
+/**
+ * remove empty message slots without first creating a structured clone
+ */
+export function removeSlots(messageBundle: MessageBundleWithSlots) {
+	messageBundle.messages = messageBundle.messages.filter((message) => !("slot" in message))
+	return messageBundle as MessageBundle
+}
+
+/**
+ * Add newlines between bundles and messages to avoid merge conflicts
+ */
+export function injectJSONNewlines(json: string): string {
+	return json
+		.replace(/\{"id":"/g, '\n\n\n\n{"id":"')
+		.replace(/"messages":\[\{"locale":"/g, '"messages":[\n\n\n\n{"locale":"')
+		.replace(/\}\]\}\]\},\{"locale":"/g, '}]}]},\n\n\n\n{"locale":"')
+		.replace(/"slot":true\},\{"locale":/g, '"slot":true},\n\n\n\n{"locale":')
+}

package/src/v2/index.ts

@@ -1 +1,3 @@
 export type * from "./types.js"
+export * from "./helper.js"
+export * from "./shim.js"

package/src/v2/mocks/index.ts

@@ -0,0 +1,2 @@
+export * from "./plural/bundle.js"
+export * from "./multipleMatcher/bundle.js"

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

@@ -0,0 +1,11 @@
+import { describe, it, expect } from "vitest"
+import { multipleMatcherBundle } from "./bundle.js"
+import { MessageBundle } from "../../types.js"
+import { Value } from "@sinclair/typebox/value"
+
+describe("mock plural messageBundle", () => {
+	it("is valid", () => {
+		const messageBundle: unknown = multipleMatcherBundle
+		expect(Value.Check(MessageBundle, messageBundle)).toBe(true)
+	})
+})

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

@@ -0,0 +1,196 @@
+import type { MessageBundle } from "../../types.js"
+
+export const multipleMatcherBundle: MessageBundle = {
+	id: "mock-bundle-human-id",
+	alias: {
+		default: "mock-bundle-alias",
+	},
+	messages: [
+		{
+			locale: "en",
+			declarations: [],
+			selectors: [
+				{
+					type: "expression",
+					arg: {
+						type: "variable",
+						name: "count",
+					},
+					annotation: { type: "function", name: "plural", options: [] },
+				},
+			],
+			variants: [
+				{
+					match: ["one"],
+					pattern: [
+						{
+							type: "text",
+							value: "Show ",
+						},
+						{
+							type: "expression",
+							arg: {
+								type: "variable",
+								name: "count",
+							},
+						},
+						{
+							type: "text",
+							value: " message.",
+						},
+					],
+				},
+				{
+					match: ["many"],
+					pattern: [
+						{
+							type: "text",
+							value: "Show ",
+						},
+						{
+							type: "expression",
+							arg: {
+								type: "variable",
+								name: "count",
+							},
+						},
+						{
+							type: "text",
+							value: " messages.",
+						},
+					],
+				},
+				{
+					match: ["*"],
+					pattern: [
+						{
+							type: "text",
+							value: "Show ",
+						},
+						{
+							type: "expression",
+							arg: {
+								type: "variable",
+								name: "count",
+							},
+						},
+					],
+				},
+			],
+		},
+		{
+			locale: "de",
+			declarations: [],
+			selectors: [
+				{
+					type: "expression",
+					arg: {
+						type: "variable",
+						name: "count",
+					},
+					annotation: { type: "function", name: "plural", options: [] },
+				},
+				{
+					type: "expression",
+					arg: {
+						type: "variable",
+						name: "formal",
+					},
+					annotation: { type: "function", name: "bool", options: [] },
+				},
+			],
+			variants: [
+				{
+					match: ["one", "formal"],
+					pattern: [
+						{
+							type: "text",
+							value: "Zeigen Sie bitte Ihre Nachricht.",
+						},
+					],
+				},
+				{
+					match: ["one", "informal"],
+					pattern: [
+						{
+							type: "text",
+							value: "Zeigen Deine Nachricht.",
+						},
+					],
+				},
+				{
+					match: ["many", "formal"],
+					pattern: [
+						{
+							type: "text",
+							value: "Zeigen Sie bitte Ihre ",
+						},
+						{
+							type: "expression",
+							arg: {
+								type: "variable",
+								name: "count",
+							},
+						},
+						{
+							type: "text",
+							value: " Nachrichten.",
+						},
+					],
+				},
+				{
+					match: ["many", "informal"],
+					pattern: [
+						{
+							type: "text",
+							value: "Zeigen Deine ",
+						},
+						{
+							type: "expression",
+							arg: {
+								type: "variable",
+								name: "count",
+							},
+						},
+						{
+							type: "text",
+							value: " Nachrichten.",
+						},
+					],
+				},
+				{
+					match: ["many", "*"],
+					pattern: [
+						{
+							type: "expression",
+							arg: {
+								type: "variable",
+								name: "count",
+							},
+						},
+						{
+							type: "text",
+							value: " Nachrichten zeigen.",
+						},
+					],
+				},
+				{
+					match: ["*"],
+					pattern: [
+						{
+							type: "text",
+							value: "Zeige ",
+						},
+						{
+							type: "expression",
+							arg: {
+								type: "variable",
+								name: "count",
+							},
+						},
+					],
+				},
+			],
+		},
+	],
+}

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

@@ -1,18 +1,18 @@
 /* eslint-disable @typescript-eslint/no-non-null-assertion */
 
 import { describe, it, expect } from "vitest"
-import { bundle } from "./bundle.js"
+import { pluralBundle } 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
+		const messageBundle: unknown = pluralBundle
 		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)
+		expect(pluralBundle.messages.length).toBe(2)
+		expect(pluralBundle.messages[0]!.declarations.length).toBe(1)
+		expect(pluralBundle.messages[0]!.selectors.length).toBe(1)
+		expect(pluralBundle.messages[0]!.variants.length).toBe(3)
 	})
 })

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"}