@inlang/sdk 0.36.4 → 2.0.0-beta.2

package/dist/validateProjectPath.js

@@ -1,31 +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) {
-    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) {
-    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) {
-    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/dist/validateProjectPath.test.d.ts

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

package/dist/validateProjectPath.test.d.ts.map

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

package/dist/validateProjectPath.test.js

@@ -1,40 +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/dist/versionedInterfaces.d.ts

@@ -1,8 +0,0 @@
-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";
-//# sourceMappingURL=versionedInterfaces.d.ts.map

package/dist/versionedInterfaces.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"versionedInterfaces.d.ts","sourceRoot":"","sources":["../src/versionedInterfaces.ts"],"names":[],"mappings":"AAEA,cAAc,oBAAoB,CAAA;AAClC,cAAc,sBAAsB,CAAA;AACpC,cAAc,2BAA2B,CAAA;AACzC,cAAc,iBAAiB,CAAA;AAC/B,cAAc,gBAAgB,CAAA;AAC9B,cAAc,0BAA0B,CAAA;AACxC,cAAc,sBAAsB,CAAA"}

package/dist/versionedInterfaces.js

@@ -1,8 +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";

package/src/adapter/solidAdapter.test.ts

@@ -1,472 +0,0 @@
-/* eslint-disable @typescript-eslint/no-non-null-assertion */
-import { describe, it, expect } from "vitest"
-import type { ImportFunction } from "../resolve-modules/index.js"
-import { createEffect, from, createRoot } from "../reactivity/solid.js"
-import { solidAdapter } from "./solidAdapter.js"
-import { loadProject } from "../loadProject.js"
-import { mockRepo } from "@lix-js/client"
-import type {
-	Message,
-	ProjectSettings,
-	Plugin,
-	MessageLintRule,
-	Text,
-} from "../versionedInterfaces.js"
-
-// ------------------------------------------------------------------------------------------------
-
-const config: ProjectSettings = {
-	sourceLanguageTag: "en",
-	languageTags: ["en"],
-	modules: ["plugin.js", "plugin2.js"],
-	messageLintRuleLevels: {
-		"messageLintRule.project.missingTranslation": "error",
-	},
-	"plugin.project.i18next": {
-		pathPattern: "./examples/example01/{languageTag}.json",
-		variableReferencePattern: ["{", "}"],
-	},
-}
-
-const configWithAliases: ProjectSettings = {
-	...config,
-	experimental: { aliases: true },
-}
-
-const mockPlugin: Plugin = {
-	id: "plugin.project.i18next",
-	description: { en: "Mock plugin description" },
-	displayName: { en: "Mock Plugin" },
-
-	loadMessages: () => exampleMessages,
-	saveMessages: () => undefined,
-}
-
-// TODO: use `createMessage` utility
-const exampleMessages: Message[] = [
-	{
-		id: "a",
-		alias: {},
-		selectors: [],
-		variants: [
-			{
-				languageTag: "en",
-				match: [],
-				pattern: [
-					{
-						type: "Text",
-						value: "test",
-					},
-				],
-			},
-		],
-	},
-	{
-		id: "b",
-		alias: {},
-		selectors: [],
-		variants: [
-			{
-				languageTag: "en",
-				match: [],
-				pattern: [
-					{
-						type: "Text",
-						value: "test",
-					},
-				],
-			},
-		],
-	},
-]
-
-const mockLintRule: MessageLintRule = {
-	id: "messageLintRule.namespace.mock",
-	description: { en: "Mock lint rule description" },
-	displayName: { en: "Mock Lint Rule" },
-
-	run: () => undefined,
-}
-
-const $import: ImportFunction = async (name) => ({
-	default: name === "plugin.js" ? mockPlugin : mockLintRule,
-})
-
-// ------------------------------------------------------------------------------------------------
-
-describe("config", () => {
-	it("should react to changes in config", async () => {
-		const repo = await mockRepo()
-		const fs = repo.nodeishFs
-		await fs.mkdir("/user/project.inlang", { recursive: true })
-		await fs.writeFile("/user/project.inlang/settings.json", JSON.stringify(config))
-		const project = solidAdapter(
-			await loadProject({
-				projectPath: "/user/project.inlang",
-				repo,
-				_import: $import,
-			}),
-			{ from }
-		)
-
-		let counter = 0
-		createEffect(() => {
-			project.settings()
-			counter += 1
-		})
-
-		// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-		const newConfig = { ...project.settings()!, languageTags: ["en", "de"] }
-
-		project.setSettings(newConfig)
-
-		// TODO: how can we await `setConfig` correctly
-		await new Promise((resolve) => setTimeout(resolve, 510))
-
-		expect(counter).toBe(2) // 2 times because effect creation + set
-		expect(project.settings()).toStrictEqual(newConfig)
-	})
-})
-
-describe("installed", () => {
-	it("react to changes that are unrelated to installed items", async () => {
-		const repo = await mockRepo()
-		const fs = repo.nodeishFs
-		await fs.mkdir("/user/project.inlang", { recursive: true })
-		await fs.writeFile("/user/project.inlang/settings.json", JSON.stringify(config))
-		const project = solidAdapter(
-			await loadProject({
-				projectPath: "/user/project.inlang",
-				repo,
-				_import: $import,
-			}),
-			{ from }
-		)
-		let counterPlugins = 0
-		let counterLint = 0
-
-		createEffect(() => {
-			project.installed.plugins()
-			counterPlugins += 1
-		})
-
-		createEffect(() => {
-			project.installed.messageLintRules()
-			counterLint += 1
-		})
-
-		project.setSettings({ ...project.settings()!, languageTags: ["en", "fr"] })
-
-		// TODO: how can we await `setConfig` correctly
-		await new Promise((resolve) => setTimeout(resolve, 0))
-
-		expect(counterPlugins).toBe(3) // 3 times because effect creation + setSettings, setResolvedModules
-		expect(counterLint).toBe(3) // 3 times because effect creation + setSettings, setResolvedModules
-	})
-})
-
-describe("messages", () => {
-	it("should react to changes in config", async () => {
-		const repo = await mockRepo()
-		const fs = repo.nodeishFs
-		const mockConfig: ProjectSettings = {
-			sourceLanguageTag: "en",
-			languageTags: ["en", "de"],
-			modules: ["./plugin-a.js"],
-			"library.project.paraglideJsSveltekit": {
-				languageNegotiation: {
-					strategies: [
-						{
-							type: "localStorage",
-						} as any,
-					],
-				},
-			},
-		}
-		const mockPlugin: Plugin = {
-			id: "plugin.mock.id",
-			displayName: {
-				en: "hello",
-			},
-			description: {
-				en: "wo",
-			},
-
-			loadMessages: ({ settings }) => (settings.languageTags.length ? exampleMessages : []),
-			saveMessages: () => undefined,
-		}
-
-		const mockImport: ImportFunction = async () => ({ default: mockPlugin })
-
-		await fs.mkdir("/user/project.inlang.inlang", { recursive: true })
-		await fs.writeFile("/user/project.inlang.inlang/settings.json", JSON.stringify(mockConfig))
-		const project = solidAdapter(
-			await loadProject({
-				projectPath: "/user/project.inlang.inlang",
-				repo,
-				_import: mockImport,
-			}),
-			{ from }
-		)
-
-		let effectOnMessagesCounter = -1
-		createEffect(() => {
-			project.query.messages.getAll()
-			effectOnMessagesCounter += 1
-		})
-
-		expect(Object.values(project.query.messages.getAll()).length).toBe(2)
-
-		project.setSettings({ ...project.settings()!, languageTags: ["en"] })
-
-		// TODO: how can we await `setConfig` correctly
-		await new Promise((resolve) => setTimeout(resolve, 510))
-
-		expect(effectOnMessagesCounter).toBe(2) // 2 = setSetting (clearing the message index), subsequencial loadMessage call
-		expect(Object.values(project.query.messages.getAll()).length).toBe(2)
-	})
-
-	it("should react to message udpate", async () => {
-		const repo = await mockRepo()
-		const fs = repo.nodeishFs
-		await fs.mkdir("/user/project.inlang.inlang", { recursive: true })
-		await fs.writeFile("/user/project.inlang.inlang/settings.json", JSON.stringify(config))
-		const project = solidAdapter(
-			await loadProject({
-				projectPath: "/user/project.inlang.inlang",
-				repo,
-				_import: $import,
-			}),
-			{ from }
-		)
-
-		let counter = 0
-		createEffect(() => {
-			project.query.messages.getAll()
-			counter += 1
-		})
-
-		const messagesBefore = project.query.messages.getAll
-		expect(Object.values(messagesBefore()).length).toBe(2)
-		expect(
-			(
-				Object.values(messagesBefore())[0]?.variants.find((variant) => variant.languageTag === "en")
-					?.pattern[0] as Text
-			).value
-		).toBe("test")
-
-		project.query.messages.update({
-			where: { id: "a" },
-			// TODO: use `createMessage` utility
-			data: {
-				...exampleMessages[0],
-				variants: [
-					{
-						languageTag: "en",
-						match: [],
-						pattern: [
-							{
-								type: "Text",
-								value: "test2",
-							},
-						],
-					},
-				],
-			},
-		})
-
-		it("should react to message udpate (with aliases)", async () => {
-			const repo = await mockRepo()
-			const fs = repo.nodeishFs
-			await fs.mkdir("/user/project.inlang.inlang", { recursive: true })
-			await fs.writeFile(
-				"/user/project.inlang.inlang/settings.json",
-				JSON.stringify(configWithAliases)
-			)
-			const project = solidAdapter(
-				await loadProject({
-					projectPath: "/user/project.inlang.inlang",
-					repo,
-					_import: $import,
-				}),
-				{ from }
-			)
-
-			let counter = 0
-			createEffect(() => {
-				project.query.messages.getAll()
-				counter += 1
-			})
-
-			const messagesBefore = project.query.messages.getAll
-			expect(Object.values(messagesBefore()).length).toBe(2)
-			expect(
-				(
-					Object.values(messagesBefore())[0]?.variants.find(
-						(variant) => variant.languageTag === "en"
-					)?.pattern[0] as Text
-				).value
-			).toBe("test")
-
-			project.query.messages.update({
-				where: { id: "raw_tapir_pause_grateful" },
-				// TODO: use `createMessage` utility
-				data: {
-					...exampleMessages[0],
-					variants: [
-						{
-							languageTag: "en",
-							match: [],
-							pattern: [
-								{
-									type: "Text",
-									value: "test2",
-								},
-							],
-						},
-					],
-				},
-			})
-
-			expect(counter).toBe(2) // 2 times because effect creation + set
-			const messagesAfter = project.query.messages.getAll
-			expect(Object.values(messagesAfter()).length).toBe(2)
-			expect(
-				(
-					Object.values(messagesAfter())[0]?.variants.find(
-						(variant) => variant.languageTag === "en"
-					)?.pattern[0] as Text
-				).value
-			).toBe("test2")
-		})
-
-		expect(counter).toBe(2) // 2 times because effect creation + set
-		const messagesAfter = project.query.messages.getAll
-		expect(Object.values(messagesAfter()).length).toBe(2)
-		expect(
-			(
-				Object.values(messagesAfter())[0]?.variants.find((variant) => variant.languageTag === "en")
-					?.pattern[0] as Text
-			).value
-		).toBe("test2")
-	})
-})
-
-describe("lint", () => {
-	it("should react to changes in config", async () => {
-		await createRoot(async () => {
-			const repo = await mockRepo()
-			const fs = repo.nodeishFs
-			await fs.mkdir("/user/project.inlang", { recursive: true })
-			await fs.writeFile("/user/project.inlang/settings.json", JSON.stringify(config))
-			const project = solidAdapter(
-				await loadProject({
-					projectPath: "/user/project.inlang",
-					repo,
-					_import: $import,
-				}),
-				{ from }
-			)
-
-			// set counter to -1 since creating effect will execute once
-			let counter = -1
-			createEffect(() => {
-				project.query.messageLintReports.getAll()
-				counter += 1
-			})
-
-			expect(counter).toBe(0)
-
-			// wait for all int reports beeing executed
-			await new Promise((resolve) => setTimeout(resolve, 510))
-
-			// 1 because we batch the two lint rules
-			expect(counter).toBe(1)
-
-			const currentSettings = project.settings()!
-			const newConfig = { ...currentSettings, languageTags: ["en", "de"] }
-			project.setSettings(newConfig)
-
-			// set settings trigges synchronous -> +1
-			expect(counter).toBe(2)
-
-			await new Promise((resolve) => setTimeout(resolve, 510))
-
-			// 4 = 2 + batched(1 (effect->settings) and  1 (effect->Resolved Plugin))
-			expect(counter).toBe(3)
-			expect(project.query.messageLintReports.getAll()).toEqual([])
-
-			await new Promise((resolve) => setTimeout(resolve, 510))
-
-			const newConfig2 = { ...project.settings()!, languageTags: ["en", "de", "fr"] }
-			project.setSettings(newConfig2)
-
-			// set settings trigges synchronous -> +1
-			expect(counter).toBe(4)
-
-			await new Promise((resolve) => setTimeout(resolve, 510))
-
-			// 5 -> 4 + 1 new lint report batch
-			expect(counter).toBe(5)
-			expect(project.query.messageLintReports.getAll()).toEqual([])
-		})
-	})
-
-	it.todo("should react to changes to packages")
-	it.todo("should react to changes to modules")
-
-	it("should react to changes to messages", async () => {
-		await createRoot(async () => {
-			const repo = await mockRepo()
-			const fs = repo.nodeishFs
-			await fs.mkdir("/user/project.inlang", { recursive: true })
-			await fs.writeFile("/user/project.inlang/settings.json", JSON.stringify(config))
-			const project = solidAdapter(
-				await loadProject({
-					projectPath: "/user/project.inlang",
-					repo,
-					_import: $import,
-				}),
-				{ from }
-			)
-
-			let counter = -1 // -1 to start counting after the initial effect
-			createEffect(() => {
-				project.query.messageLintReports.getAll()
-				counter += 1
-			})
-			expect(counter).toBe(0)
-
-			await new Promise((resolve) => setTimeout(resolve, 510))
-			// 1 -> lint rules are batched - we expect one signal on getAll
-			expect(counter).toBe(1)
-
-			project.query.messages.update({
-				where: { id: "a" },
-				data: {
-					...exampleMessages[0],
-					variants: [{ languageTag: "en", match: [], pattern: [{ type: "Text", value: "new" }] }],
-				},
-			})
-			await new Promise((resolve) => setTimeout(resolve, 510))
-
-			// 1 -> previous two messages + 0 - report results are the same - no effect
-			expect(counter).toBe(1)
-			expect(project.query.messageLintReports.getAll()).toEqual([])
-
-			project.query.messages.update({
-				where: { id: "a" },
-				data: {
-					...exampleMessages[0],
-					variants: [{ languageTag: "en", match: [], pattern: [{ type: "Text", value: "new" }] }],
-				},
-			})
-
-			await new Promise((resolve) => setTimeout(resolve, 510))
-
-			// 2 -> the updated message does not update the lint rules - result is the same
-			expect(counter).toBe(1)
-			expect(project.query.messageLintReports.getAll()).toEqual([])
-		})
-	})
-})

package/src/adapter/solidAdapter.ts

@@ -1,79 +0,0 @@
-import type { InlangProject, MessageLintReportsQueryApi } from "../api.js"
-import { observable, type from as solidFrom } from "../reactivity/solid.js"
-import type { MessageQueryApi } from "@inlang/sdk"
-
-export const solidAdapter = (
-	project: InlangProject,
-	arg: {
-		from: typeof solidFrom
-	}
-): InlangProjectWithSolidAdapter => {
-	const convert = <T>(signal: () => T): (() => T) => {
-		return arg.from(observable(signal)) as () => T
-	}
-
-	return {
-		id: project.id,
-		customApi: convert(project.customApi),
-		settings: convert(project.settings),
-		errors: convert(project.errors),
-		installed: {
-			messageLintRules: convert(project.installed.messageLintRules),
-			plugins: convert(project.installed.plugins),
-		},
-		setSettings: project.setSettings,
-		query: {
-			messages: {
-				create: project.query.messages.create,
-				update: project.query.messages.update,
-				delete: project.query.messages.delete,
-				upsert: project.query.messages.upsert,
-				get: project.query.messages.get,
-				// get: (args) => {
-				// 	const [message, setMessage] = createSignal<Message | undefined>()
-				// 	project.query.messages.get.subscribe(args, setMessage)
-				// 	return message()
-				// },
-				getAll: convert(project.query.messages.getAll),
-				includedMessageIds: convert(project.query.messages.includedMessageIds),
-			},
-			messageLintReports: {
-				get: project.query.messageLintReports.get,
-				getAll: convert(project.query.messageLintReports.getAll),
-			},
-		},
-	} satisfies InlangProjectWithSolidAdapter
-}
-
-export type InlangProjectWithSolidAdapter = {
-	id: InlangProject["id"]
-	customApi: () => ReturnType<InlangProject["customApi"]>
-	installed: {
-		plugins: () => ReturnType<InlangProject["installed"]["plugins"]>
-		messageLintRules: () => ReturnType<InlangProject["installed"]["messageLintRules"]>
-	}
-	errors: () => ReturnType<InlangProject["errors"]>
-	settings: () => ReturnType<InlangProject["settings"]>
-	setSettings: InlangProject["setSettings"]
-	query: {
-		messages: {
-			create: MessageQueryApi["create"]
-			update: MessageQueryApi["update"]
-			delete: MessageQueryApi["delete"]
-			upsert: MessageQueryApi["upsert"]
-			get: MessageQueryApi["get"]
-			//get: (args: Parameters<MessageQueryApi["get"]>[0]) => ReturnType<MessageQueryApi["get"]>
-			getAll: () => ReturnType<MessageQueryApi["getAll"]>
-			includedMessageIds: () => ReturnType<MessageQueryApi["includedMessageIds"]>
-		}
-		messageLintReports: {
-			get: MessageLintReportsQueryApi["get"]
-			getAll: () => ReturnType<MessageLintReportsQueryApi["getAll"]>
-		}
-	}
-}
-
-// const x = {} as InlangProjectWithSolidAdapter
-// x.query.lintReports.getAll()
-
-// console.log(await x.lint())

package/src/api.test-d.ts

@@ -1,8 +0,0 @@
-import type { ProjectSettings } from "@inlang/project-settings"
-import type { InlangProject } from "./api.js"
-import { expectType } from "tsd"
-
-const project: InlangProject = {} as any
-
-// it should not have potentially undefined settings.
-expectType<ProjectSettings>(project.settings())