@inlang/sdk 0.36.3 → 2.0.0-prerelease.0

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

@@ -1,164 +0,0 @@
-import type { MessageBundle } from "../../types.js"
-
-export const pluralBundle: 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",
-						},
-					},
-				},
-				{
-					type: "input",
-					name: "count",
-					value: {
-						type: "expression",
-						arg: {
-							type: "variable",
-							name: "count",
-						},
-					},
-				},
-				{
-					type: "input",
-					name: "projectCount",
-					value: {
-						type: "expression",
-						arg: {
-							type: "variable",
-							name: "projectCount",
-						},
-					},
-				},
-			],
-			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",
-						},
-					],
-				},
-			],
-		},
-	],
-}

package/src/v2/shim.test.ts

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

@@ -1,173 +0,0 @@
-/**
- * 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

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

@@ -1,159 +0,0 @@
-import { Type, type Static } from "@sinclair/typebox"
-
-/**
- * Follows the IETF BCP 47 language tag schema.
- *
- * @see https://www.ietf.org/rfc/bcp/bcp47.txt
- * @see https://www.iana.org/assignments/language-subtag-registry/language-subtag-registry
- */
-export type LanguageTag = Static<typeof LanguageTag>
-/**
- * Follows the IETF BCP 47 language tag schema with modifications.
- * @see REAMDE.md file for more information on the validation.
- */
-
-export const pattern =
-	"^((?<grandfathered>(en-GB-oed|i-ami|i-bnn|i-default|i-enochian|i-hak|i-klingon|i-lux|i-mingo|i-navajo|i-pwn|i-tao|i-tay|i-tsu|sgn-BE-FR|sgn-BE-NL|sgn-CH-DE)|(art-lojban|cel-gaulish|no-bok|no-nyn|zh-guoyu|zh-hakka|zh-min|zh-min-nan|zh-xiang))|((?<language>([A-Za-z]{2,3}(-(?<extlang>[A-Za-z]{3}(-[A-Za-z]{3}){0,2}))?))(-(?<script>[A-Za-z]{4}))?(-(?<region>[A-Za-z]{2}|[0-9]{3}))?(-(?<variant>[A-Za-z0-9]{5,8}|[0-9][A-Za-z0-9]{3}))*))$"
-
-export const LanguageTag = Type.String({
-	pattern: pattern,
-	description: "The language tag must be a valid IETF BCP 47 language tag.",
-	examples: ["en", "de", "en-US", "zh-Hans", "es-419"],
-})
-
-export type Literal = Static<typeof Literal>
-export const Literal = Type.Object({
-	type: Type.Literal("literal"),
-	value: Type.String(),
-})
-
-/**
- * A (text) element that is translatable and rendered to the UI.
- */
-export type Text = Static<typeof Text>
-export const Text = Type.Object({
-	type: Type.Literal("text"),
-	value: Type.String(),
-})
-
-export type VariableReference = Static<typeof VariableReference>
-export const VariableReference = Type.Object({
-	type: Type.Literal("variable"),
-	name: Type.String(),
-})
-
-export type Option = Static<typeof Option>
-export const Option = Type.Object({
-	name: Type.String(),
-	value: Type.Union([Literal, VariableReference]),
-})
-
-export type FunctionAnnotation = Static<typeof FunctionAnnotation>
-export const FunctionAnnotation = Type.Object({
-	type: Type.Literal("function"),
-	name: Type.String(),
-	options: Type.Array(Option),
-})
-
-/**
- * An expression is a reference to a variable or a function.
- *
- * Think of expressions as elements that are rendered to a
- * text value during runtime.
- */
-export type Expression = Static<typeof Expression>
-export const Expression = Type.Object({
-	type: Type.Literal("expression"),
-	arg: Type.Union([Literal, VariableReference]),
-	annotation: Type.Optional(FunctionAnnotation),
-})
-
-// export type FunctionReference = {
-// 	type: "function"
-// 	name: string
-// 	operand?: Text | VariableReference
-// 	options?: Option[]
-// }
-
-/**
- * A pattern is a sequence of elements that comprise
- * a message that is rendered to the UI.
- */
-export type Pattern = Static<typeof Pattern>
-export const Pattern = Type.Array(Type.Union([Text, Expression]))
-
-/**
- * A variant contains a pattern that is rendered to the UI.
- */
-export type Variant = Static<typeof Variant>
-export const Variant = Type.Object({
-	/**
-	 * The number of keys in each variant match MUST equal the number of expressions in the selectors.
-	 *
-	 * Inspired by: https://github.com/unicode-org/message-format-wg/blob/main/spec/formatting.md#pattern-selection
-	 */
-	// a match can always only be string-based because a string is what is rendered to the UI
-	match: Type.Array(Type.String()),
-	pattern: Pattern,
-})
-
-export type InputDeclaration = Static<typeof InputDeclaration>
-export const InputDeclaration = Type.Object({
-	type: Type.Literal("input"),
-	name: Type.String(),
-
-	//TODO make this generic so that only Variable-Ref Expressions are allowed
-	value: Expression,
-})
-
-// local declarations are not supported.
-// Will only add when required. See discussion:
-// https://github.com/opral/monorepo/pull/2700#discussion_r1591070701
-//
-// export type LocalDeclaration = Static<typeof InputDeclaration>
-// export const LocalDeclaration = Type.Object({
-// 	type: Type.Literal("local"),
-// 	name: Type.String(),
-// 	value: Expression,
-// })
-//
-// export type Declaration = Static<typeof Declaration>
-// export const Declaration = Type.Union([LocalDeclaration, InputDeclaration])
-
-export type Declaration = Static<typeof Declaration>
-export const Declaration = Type.Union([InputDeclaration])
-
-export type Message = Static<typeof Message>
-export const Message = Type.Object({
-	locale: LanguageTag,
-	declarations: Type.Array(Declaration),
-	/**
-	 * The order in which the selectors are placed determines the precedence of patterns.
-	 */
-	selectors: Type.Array(Expression),
-	variants: Type.Array(Variant),
-})
-
-export type MessageBundle = Static<typeof MessageBundle>
-export const MessageBundle = Type.Object({
-	id: Type.String(),
-	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/src/validateProjectPath.test.ts

@@ -1,50 +0,0 @@
-import { assert, describe, it } from "vitest"
-import {
-	assertValidProjectPath,
-	isAbsolutePath,
-	isInlangProjectPath,
-} from "./validateProjectPath.js"
-
-describe("isAbsolutePath", () => {
-	it("should correctly identify Unix absolute paths", () => {
-		assert.isTrue(isAbsolutePath("/home/user/documents/file.txt"))
-		assert.isTrue(isAbsolutePath("/usr/local/bin/script.sh"))
-		assert.isFalse(isAbsolutePath("relative/path/to/file.txt"))
-	})
-
-	it("should correctly identify Windows absolute paths", () => {
-		assert.isTrue(isAbsolutePath("C:\\Users\\User\\Documents\\File.txt"))
-		assert.isTrue(isAbsolutePath("C:/Users/user/project.inlang/settings.json"))
-		assert.isFalse(isAbsolutePath("Projects\\Project1\\source\\file.txt"))
-	})
-
-	it("should handle edge cases", () => {
-		assert.isFalse(isAbsolutePath("")) // Empty path should return false
-		assert.isFalse(isAbsolutePath("relative/path/../file.txt")) // Relative path with ".." should return false
-		assert.isFalse(isAbsolutePath("../relative/path/to/file.txt"))
-		assert.isFalse(isAbsolutePath("./relative/path/to/file.txt"))
-	})
-})
-
-describe("isInlangProjectPath", () => {
-	it("should correctly identify valid inlang project paths", () => {
-		assert.isTrue(isInlangProjectPath("/path/to/orange-mouse.inlang"))
-		assert.isFalse(isInlangProjectPath("relative/path/to/file.txt"))
-		assert.isFalse(isInlangProjectPath("/path/to/.inlang"))
-		assert.isFalse(isInlangProjectPath("/path/to/white-elephant.inlang/"))
-		assert.isFalse(isInlangProjectPath("/path/to/blue-elephant.inlang/settings.json"))
-	})
-})
-
-describe("assertValidProjectPath", () => {
-	it("should not throw for valid project paths", () => {
-		assert.doesNotThrow(() => assertValidProjectPath("/path/to/brown-mouse.inlang"))
-		assert.doesNotThrow(() => assertValidProjectPath("/path/to/green-elephant.inlang"))
-	})
-
-	it("should throw for invalid project paths", () => {
-		assert.throws(() => assertValidProjectPath("relative/path/to/flying-lizard.inlang"))
-		assert.throws(() => assertValidProjectPath("/path/to/loud-mouse.inlang/"))
-		assert.throws(() => assertValidProjectPath("/path/to/green-elephant.inlang/settings.json"))
-	})
-})

package/src/validateProjectPath.ts

@@ -1,38 +0,0 @@
-/**
- * validate that a project path is absolute and ends with {name}.inlang.
- *
- * @throws if the path is not valid.
- */
-export function assertValidProjectPath(
-	projectPath: string
-): asserts projectPath is `${string}.inlang` {
-	if (!isAbsolutePath(projectPath)) {
-		throw new Error(`Expected an absolute path but received "${projectPath}".`)
-	}
-	if (!isInlangProjectPath(projectPath)) {
-		throw new Error(
-			`Expected a path ending in "{name}.inlang" but received "${projectPath}".\n\nValid examples: \n- "/path/to/micky-mouse.inlang"\n- "/path/to/green-elephant.inlang\n`
-		)
-	}
-}
-
-/**
- * tests whether a path ends with {name}.inlang
- * (does not remove trailing slash)
- */
-export function isInlangProjectPath(path: string): path is `${string}.inlang` {
-	return /[^\\/]+\.inlang$/.test(path)
-}
-
-/**
- * tests whether a path starts with a forward slash (/) or a windows-style
- * drive letter (C: or D:, etc.) followed by a slash
- */
-export function isAbsolutePath(path: string) {
-	return /^\/|^[A-Za-z]:[\\/]/.test(path)
-
-	// OG from sdk/src/isAbsolutePath.ts - TODO: find out where this regex came from
-	// const matchPosixAndWindowsAbsolutePaths =
-	// 	/^(?:[A-Za-z]:\\(?:[^\\]+\\)*[^\\]+|[A-Za-z]:\/(?:[^/]+\/)*[^/]+|\/(?:[^/]+\/)*[^/]+)$/
-	// return matchPosixAndWindowsAbsolutePaths.test(path)
-}

package/src/versionedInterfaces.ts

@@ -1,9 +0,0 @@
-// Re-exporting for easier importing
-
-export * from "@inlang/json-types"
-export * from "@inlang/language-tag"
-export * from "@inlang/message-lint-rule"
-export * from "@inlang/message"
-export * from "@inlang/plugin"
-export * from "@inlang/project-settings"
-export * from "@inlang/translatable"