@inlang/sdk 0.1.0

package/src/openInlangProject.ts

@@ -0,0 +1,337 @@
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+import type {
+	InlangProject,
+	InstalledMessageLintRule,
+	InstalledPlugin,
+	Subscribable,
+} from "./api.js"
+import { type ImportFunction, resolveModules } from "./resolve-modules/index.js"
+import { TypeCompiler } from "@sinclair/typebox/compiler"
+import { Value } from "@sinclair/typebox/value"
+import {
+	ProjectFilePathNotFoundError,
+	ProjectFileJSONSyntaxError,
+	InvalidConfigError,
+	NoPluginProvidesLoadOrSaveMessagesError,
+	PluginLoadMessagesError,
+	PluginSaveMessagesError,
+} from "./errors.js"
+import { createRoot, createSignal, createEffect } from "./reactivity/solid.js"
+import { createMessagesQuery } from "./createMessagesQuery.js"
+import { debounce } from "throttle-debounce"
+import { createMessageLintReportsQuery } from "./createMessageLintReportsQuery.js"
+import { ProjectConfig, Message, type NodeishFilesystemSubset } from "./versionedInterfaces.js"
+import { tryCatch, type Result } from "@inlang/result"
+
+const ConfigCompiler = TypeCompiler.Compile(ProjectConfig)
+
+/**
+ * Creates an inlang instance.
+ *
+ * - Use `_import` to pass a custom import function for testing,
+ *   and supporting legacy resolvedModules such as CJS.
+ *
+ */
+export const openInlangProject = async (args: {
+	projectFilePath: string
+	nodeishFs: NodeishFilesystemSubset
+	_import?: ImportFunction
+	_capture?: (id: string, props: Record<string, unknown>) => void
+}): Promise<InlangProject> => {
+	return await createRoot(async () => {
+		const [initialized, markInitAsComplete, markInitAsFailed] = createAwaitable()
+
+		// -- config ------------------------------------------------------------
+
+		const [config, _setConfig] = createSignal<ProjectConfig>()
+		createEffect(() => {
+			loadConfig({ projectFilePath: args.projectFilePath, nodeishFs: args.nodeishFs })
+				.then((config) => {
+					setConfig(config)
+					args._capture?.("SDK used config", config)
+				})
+				.catch((err) => {
+					markInitAsFailed(err)
+				})
+		})
+		// TODO: create FS watcher and update config on change
+
+		const writeConfigToDisk = skipFirst((config: ProjectConfig) =>
+			_writeConfigToDisk({ nodeishFs: args.nodeishFs, config }),
+		)
+
+		const setConfig = (config: ProjectConfig): Result<void, InvalidConfigError> => {
+			try {
+				const validatedConfig = validateConfig(config)
+				_setConfig(validatedConfig)
+
+				writeConfigToDisk(validatedConfig)
+				return { data: undefined }
+			} catch (error: unknown) {
+				if (error instanceof InvalidConfigError) {
+					return { error }
+				}
+
+				throw new Error("unhandled")
+			}
+		}
+
+		// -- resolvedModules -----------------------------------------------------------
+
+		const [resolvedModules, setResolvedModules] =
+			createSignal<Awaited<ReturnType<typeof resolveModules>>>()
+
+		createEffect(() => {
+			const conf = config()
+			if (!conf) return
+
+			loadModules({ config: conf, nodeishFs: args.nodeishFs, _import: args._import })
+				.then((resolvedModules) => {
+					// TODO move to resolveModules
+					if (
+						!resolvedModules.resolvedPluginApi.loadMessages ||
+						!resolvedModules.resolvedPluginApi.saveMessages
+					) {
+						throw new NoPluginProvidesLoadOrSaveMessagesError()
+					}
+					setResolvedModules(resolvedModules)
+
+					// TODO: handle `detectedLanguageTags`
+				})
+				.catch((err) => markInitAsFailed(err))
+		})
+
+		// -- messages ----------------------------------------------------------
+
+		let configValue: ProjectConfig
+		createEffect(() => (configValue = config()!)) // workaround to not run effects twice (e.g. config change + modules change) (I'm sure there exists a solid way of doing this, but I haven't found it yet)
+
+		const [messages, setMessages] = createSignal<Message[]>()
+		createEffect(() => {
+			const conf = config()
+			if (!conf) return
+
+			const _resolvedModules = resolvedModules()
+			if (!_resolvedModules) return
+
+			if (!_resolvedModules.resolvedPluginApi.loadMessages) {
+				markInitAsFailed(undefined)
+				return
+			}
+
+			makeTrulyAsync(
+				_resolvedModules.resolvedPluginApi.loadMessages({
+					languageTags: configValue!.languageTags,
+					sourceLanguageTag: configValue!.sourceLanguageTag,
+				}),
+			)
+				.then((messages) => {
+					setMessages(messages)
+					markInitAsComplete()
+				})
+				.catch((err) =>
+					markInitAsFailed(new PluginLoadMessagesError("Error in load messages", { cause: err })),
+				)
+		})
+
+		// -- installed items ----------------------------------------------------
+
+		const installedMessageLintRules = () => {
+			if (!resolvedModules()) return []
+			return resolvedModules()!.messageLintRules.map(
+				(rule) =>
+					({
+						meta: rule.meta,
+						module:
+							resolvedModules()?.meta.find((m) => m.id.includes(rule.meta.id))?.module ??
+							"Unknown module. You stumbled on a bug in inlang's source code. Please open an issue.",
+
+						// default to warning, see https://github.com/inlang/inlang/issues/1254
+						lintLevel:
+							configValue.settings["project.messageLintRuleLevels"]?.[rule.meta.id] ?? "warning",
+					} satisfies InstalledMessageLintRule),
+			) satisfies Array<InstalledMessageLintRule>
+		}
+
+		const installedPlugins = () => {
+			if (!resolvedModules()) return []
+			return resolvedModules()!.plugins.map((plugin) => ({
+				meta: plugin.meta,
+				module:
+					resolvedModules()?.meta.find((m) => m.id.includes(plugin.meta.id))?.module ??
+					"Unknown module. You stumbled on a bug in inlang's source code. Please open an issue.",
+			})) satisfies Array<InstalledPlugin>
+		}
+
+		// -- app ---------------------------------------------------------------
+
+		const initializeError: Error | undefined = await initialized.catch((error) => error)
+
+		const messagesQuery = createMessagesQuery(() => messages() || [])
+		const lintReportsQuery = createMessageLintReportsQuery(
+			messages,
+			config,
+			installedMessageLintRules,
+			resolvedModules,
+		)
+
+		const debouncedSave = skipFirst(
+			debounce(
+				500,
+				async (newMessages) => {
+					try {
+						await resolvedModules()!.resolvedPluginApi.saveMessages({ messages: newMessages })
+					} catch (err) {
+						throw new PluginSaveMessagesError("Error in saving messages", {
+							cause: err,
+						})
+					}
+					if (
+						newMessages.length !== 0 &&
+						JSON.stringify(newMessages) !== JSON.stringify(messages())
+					) {
+						setMessages(newMessages)
+					}
+				},
+				{ atBegin: false },
+			),
+		)
+
+		createEffect(() => {
+			debouncedSave(messagesQuery.getAll())
+		})
+
+		return {
+			installed: {
+				plugins: createSubscribable(() => installedPlugins()),
+				messageLintRules: createSubscribable(() => installedMessageLintRules()),
+			},
+			errors: createSubscribable(() => [
+				...(initializeError ? [initializeError] : []),
+				...(resolvedModules() ? resolvedModules()!.errors : []),
+				// have a query error exposed
+				//...(lintErrors() ?? []),
+			]),
+			config: createSubscribable(() => config()),
+			setConfig,
+			customApi: createSubscribable(() => resolvedModules()?.resolvedPluginApi.customApi || {}),
+			query: {
+				messages: messagesQuery,
+				messageLintReports: lintReportsQuery,
+			},
+		} satisfies InlangProject
+	})
+}
+
+//const x = {} as InlangProject
+
+// ------------------------------------------------------------------------------------------------
+
+const loadConfig = async (args: {
+	projectFilePath: string
+	nodeishFs: NodeishFilesystemSubset
+}) => {
+	const { data: configFile, error: configFileError } = await tryCatch(
+		async () => await args.nodeishFs.readFile(args.projectFilePath, { encoding: "utf-8" }),
+	)
+	if (configFileError)
+		throw new ProjectFilePathNotFoundError(
+			`Could not locate config file in (${args.projectFilePath}).`,
+			{
+				cause: configFileError,
+			},
+		)
+
+	const { data: parsedConfig, error: parseConfigError } = tryCatch(() => JSON.parse(configFile!))
+	if (parseConfigError)
+		throw new ProjectFileJSONSyntaxError(`The config is not a valid JSON file.`, {
+			cause: parseConfigError,
+		})
+	return validateConfig(parsedConfig)
+}
+
+const validateConfig = (config: unknown) => {
+	const typeErrors = [...ConfigCompiler.Errors(config)]
+	if (typeErrors.length > 0) {
+		throw new InvalidConfigError(`The config is invalid according to the schema.`, {
+			cause: typeErrors,
+		})
+	}
+
+	// @ts-ignore - fix after refactor
+	return Value.Cast(ProjectConfig, config)
+}
+
+const _writeConfigToDisk = async (args: {
+	nodeishFs: NodeishFilesystemSubset
+	config: ProjectConfig
+}) => {
+	const { data: serializedConfig, error: serializeConfigError } = tryCatch(() =>
+		// TODO: this will probably not match the original formatting
+		JSON.stringify(args.config, undefined, 2),
+	)
+	if (serializeConfigError) throw serializeConfigError
+
+	const { error: writeConfigError } = await tryCatch(async () =>
+		args.nodeishFs.writeFile("./project.inlang.json", serializedConfig!),
+	)
+	if (writeConfigError) throw writeConfigError
+}
+
+// ------------------------------------------------------------------------------------------------
+
+const loadModules = async (args: {
+	config: ProjectConfig
+	nodeishFs: NodeishFilesystemSubset
+	_import?: ImportFunction
+}) =>
+	resolveModules({
+		config: args.config,
+		nodeishFs: args.nodeishFs,
+		_import: args._import,
+	})
+
+const createAwaitable = () => {
+	let resolve: () => void
+	let reject: () => void
+
+	const promise = new Promise<void>((res, rej) => {
+		resolve = res
+		reject = rej
+	})
+
+	return [promise, resolve!, reject!] as [
+		awaitable: Promise<void>,
+		resolve: () => void,
+		reject: (e: unknown) => void,
+	]
+}
+
+// ------------------------------------------------------------------------------------------------
+
+// TODO: create global util type
+type MaybePromise<T> = T | Promise<T>
+
+const makeTrulyAsync = <T>(fn: MaybePromise<T>): Promise<T> => (async () => fn)()
+
+// Skip initial call, eg. to skip setup of a createEffect
+function skipFirst(func: (args: any) => any) {
+	let initial = false
+	return function (...args: any) {
+		if (initial) {
+			// @ts-ignore
+			return func.apply(this, args)
+		}
+		initial = true
+	}
+}
+
+export function createSubscribable<T>(signal: () => T): Subscribable<T> {
+	return Object.assign(signal, {
+		subscribe: (callback: (value: T) => void) => {
+			createEffect(() => {
+				callback(signal())
+			})
+		},
+	})
+}

package/src/parseConfig.ts

@@ -0,0 +1,33 @@
+import { ProjectConfig } from "./versionedInterfaces.js"
+import type { Result } from "@inlang/result"
+import { TypeCompiler } from "@sinclair/typebox/compiler"
+
+export class ParseConfigError extends Error {
+	readonly #id = "ParseConfigException"
+
+	constructor(message: string, cause?: string) {
+		super(message)
+		this.name = this.#id
+		this.cause = cause
+	}
+}
+
+// @ts-ignore - fix after refactor
+const ConfigCompiler = TypeCompiler.Compile(ProjectConfig)
+
+export const parseConfig = (config: ProjectConfig): Result<ProjectConfig, ParseConfigError> => {
+	if (ConfigCompiler.Check(config)) {
+		return {
+			data: config,
+			error: undefined as never,
+		}
+	} else {
+		return {
+			error: new ParseConfigError(
+				"The inlang config is not valid.",
+				[...ConfigCompiler.Errors(config)].toString(),
+			),
+			data: undefined as never,
+		}
+	}
+}

package/src/reactivity/map.ts

@@ -0,0 +1,135 @@
+// @ts-nocheck
+/* eslint-disable */
+
+import { batch } from "./solid.js"
+import { TriggerCache } from "./trigger.js"
+
+// src/index.ts
+var $KEYS = Symbol("track-keys")
+var ReactiveMap = class extends Map {
+	#keyTriggers = new TriggerCache()
+	#valueTriggers = new TriggerCache()
+	constructor(initial) {
+		super()
+		if (initial) for (const v of initial) super.set(v[0], v[1])
+	}
+	// reads
+	has(key) {
+		this.#keyTriggers.track(key)
+		return super.has(key)
+	}
+	get(key) {
+		this.#valueTriggers.track(key)
+		return super.get(key)
+	}
+	get size() {
+		this.#keyTriggers.track($KEYS)
+		return super.size
+	}
+	keys() {
+		this.#keyTriggers.track($KEYS)
+		return super.keys()
+	}
+	values() {
+		this.#keyTriggers.track($KEYS)
+		for (const v of super.keys()) this.#valueTriggers.track(v)
+		return super.values()
+	}
+	entries() {
+		this.#keyTriggers.track($KEYS)
+		for (const v of super.keys()) this.#valueTriggers.track(v)
+		return super.entries()
+	}
+	// writes
+	set(key, value) {
+		batch(() => {
+			if (super.has(key)) {
+				if (super.get(key) === value) return
+			} else {
+				this.#keyTriggers.dirty(key)
+				this.#keyTriggers.dirty($KEYS)
+			}
+			this.#valueTriggers.dirty(key)
+			super.set(key, value)
+		})
+		return this
+	}
+	delete(key) {
+		const r = super.delete(key)
+		if (r) {
+			batch(() => {
+				this.#keyTriggers.dirty(key)
+				this.#keyTriggers.dirty($KEYS)
+				this.#valueTriggers.dirty(key)
+			})
+		}
+		return r
+	}
+	clear() {
+		if (super.size) {
+			batch(() => {
+				for (const v of super.keys()) {
+					this.#keyTriggers.dirty(v)
+					this.#valueTriggers.dirty(v)
+				}
+				super.clear()
+				this.#keyTriggers.dirty($KEYS)
+			})
+		}
+	}
+	// callback
+	forEach(callbackfn) {
+		this.#keyTriggers.track($KEYS)
+		super.forEach((value, key) => callbackfn(value, key, this))
+	}
+	[Symbol.iterator]() {
+		return this.entries()
+	}
+}
+var ReactiveWeakMap = class extends WeakMap {
+	#keyTriggers = new TriggerCache(WeakMap)
+	#valueTriggers = new TriggerCache(WeakMap)
+	constructor(initial) {
+		super()
+		if (initial) for (const v of initial) super.set(v[0], v[1])
+	}
+	has(key) {
+		this.#keyTriggers.track(key)
+		return super.has(key)
+	}
+	get(key) {
+		this.#valueTriggers.track(key)
+		return super.get(key)
+	}
+	set(key, value) {
+		batch(() => {
+			if (super.has(key)) {
+				if (super.get(key) === value) return
+			} else this.#keyTriggers.dirty(key)
+			this.#valueTriggers.dirty(key)
+			super.set(key, value)
+		})
+		return this
+	}
+	delete(key) {
+		const r = super.delete(key)
+		if (r) {
+			batch(() => {
+				this.#keyTriggers.dirty(key)
+				this.#valueTriggers.dirty(key)
+			})
+		}
+		return r
+	}
+}
+function createMap(initial) {
+	const map = new ReactiveMap(initial)
+	return new Proxy(() => [...map], {
+		get: (_, b) => map[b],
+	})
+}
+function createWeakMap(initial) {
+	return new ReactiveWeakMap(initial)
+}
+
+export { ReactiveMap, ReactiveWeakMap, createMap, createWeakMap }

package/src/reactivity/solid.ts

@@ -0,0 +1,36 @@
+import {
+	createSignal as _createSignal,
+	createMemo as _createMemo,
+	createRoot as _createRoot,
+	createEffect as _createEffect,
+	observable as _observable,
+	batch as _batch,
+	from as _from,
+	getListener as _getListener,
+	onCleanup as _onCleanup,
+	DEV,
+	// @ts-ignore
+} from "solid-js/dist/solid.js"
+
+const createSignal = _createSignal as typeof import("solid-js")["createSignal"]
+const createMemo = _createMemo as typeof import("solid-js")["createMemo"]
+const createRoot = _createRoot as typeof import("solid-js")["createRoot"]
+const createEffect = _createEffect as typeof import("solid-js")["createEffect"]
+const observable = _observable as typeof import("solid-js")["observable"]
+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"]
+
+export {
+	createSignal,
+	createMemo,
+	createRoot,
+	createEffect,
+	observable,
+	from,
+	batch,
+	getListener,
+	onCleanup,
+	DEV,
+}

package/src/reactivity/trigger.ts

@@ -0,0 +1,46 @@
+// @ts-nocheck
+/* eslint-disable */
+
+import { createSignal, getListener, onCleanup, DEV } from "./solid.js"
+
+const noop = () => {}
+
+const isServer = false
+
+// src/index.ts
+var triggerOptions = !isServer && DEV ? { equals: false, name: "trigger" } : { equals: false }
+var triggerCacheOptions = !isServer && DEV ? { equals: false, internal: true } : triggerOptions
+function createTrigger() {
+	if (isServer) {
+		return [noop, noop]
+	}
+	return createSignal(void 0, triggerOptions)
+}
+var TriggerCache = class {
+	#map
+	constructor(mapConstructor = Map) {
+		this.#map = new mapConstructor()
+	}
+	dirty(key) {
+		if (isServer) return
+		this.#map.get(key)?.$$()
+	}
+	track(key) {
+		if (!getListener()) return
+		let trigger = this.#map.get(key)
+		if (!trigger) {
+			const [$, $$] = createSignal(void 0, triggerCacheOptions)
+			this.#map.set(key, (trigger = { $, $$, n: 1 }))
+		} else trigger.n++
+		onCleanup(() => {
+			if (trigger.n-- === 1) queueMicrotask(() => trigger.n === 0 && this.#map.delete(key))
+		})
+		trigger.$()
+	}
+}
+function createTriggerCache(mapConstructor = Map) {
+	const map = new TriggerCache(mapConstructor)
+	return [map.track.bind(map), map.dirty.bind(map)]
+}
+
+export { TriggerCache, createTrigger, createTriggerCache }

package/src/resolve-modules/errors.ts

@@ -0,0 +1,39 @@
+export * from "./plugins/errors.js"
+export * from "./message-lint-rules/errors.js"
+
+export class ModuleError extends Error {
+	public readonly Module: string
+	constructor(message: string, options: { module: string; cause?: Error }) {
+		super(message)
+		this.name = "ModuleError"
+		this.Module = options.module
+		this.cause = options.cause
+	}
+}
+
+/**
+ * Error when a Module does not export any plugins or lint rules.
+ */
+export class ModuleHasNoExportsError extends ModuleError {
+	constructor(message: string, options: { module: string; cause?: Error }) {
+		super(message, options)
+		this.name = "ModuleHasNoExportsError"
+	}
+}
+
+/**
+ * Error when a Module cannot be imported.
+ */
+export class ModuleImportError extends ModuleError {
+	constructor(message: string, options: { module: string; cause: Error }) {
+		super(message, options)
+		this.name = "ModuleImportError"
+	}
+}
+
+export class ModuleExportIsInvalidError extends ModuleError {
+	constructor(message: string, options: { module: string; cause?: Error }) {
+		super(message, options)
+		this.name = "ModuleExportIsInvalidError"
+	}
+}

package/src/resolve-modules/import.test.ts

@@ -0,0 +1,58 @@
+// @vitest-environment jsdom
+
+import { createNodeishMemoryFs } from "@lix-js/fs"
+import { describe, expect, it } from "vitest"
+import { createImport } from "./import.js"
+
+describe("$import", async () => {
+	const fs = createNodeishMemoryFs()
+	await fs.writeFile(
+		"./mock-module.js",
+		`
+		export function hello() {
+			return "hello";
+		}
+		`,
+	)
+
+	// mock module in a directory
+	await fs.mkdir("./nested")
+	await fs.writeFile(
+		"./nested/mock-module-two.js",
+		`
+		export function hello() {
+			return "world";
+		}
+		`,
+	)
+
+	const _import = createImport({
+		readFile: fs.readFile,
+		fetch,
+	})
+
+	it("should import a module from a local path", async () => {
+		const module = await _import("./mock-module.js")
+		expect(module.hello()).toBe("hello")
+	})
+
+	it("should import a module from a nested local path", async () => {
+		const module = await _import("./nested/mock-module-two.js")
+		expect(module.hello()).toBe("world")
+	})
+
+	it("should import an ES module from a url", async () => {
+		const module = await _import("https://cdn.jsdelivr.net/npm/normalize-url@7.2.0/index.js")
+		const normalizeUrl = module.default
+		expect(normalizeUrl("inlang.com")).toBe("http://inlang.com")
+	})
+
+	it("should throw if a module is loaded that is not an ES module", async () => {
+		try {
+			await _import("https://cdn.jsdelivr.net/npm/lodash@4.17.21")
+			throw "function did not throw"
+		} catch {
+			expect(true).toBe(true)
+		}
+	})
+})