@inlang/sdk 0.36.2 → 2.0.0-prerelease.0

package/src/reactivity/solid.test.ts

@@ -1,222 +0,0 @@
-import { describe, it, expect } from "vitest"
-import { sleep, delay } from "../test-utilities/sleep.js"
-import {
-	createRoot,
-	createSignal,
-	createEffect,
-	createMemo,
-	createResource,
-	untrack,
-} from "./solid.js"
-import { ReactiveMap } from "./map.js"
-
-describe("vitest", () => {
-	it("waits for the result of an async function", async () => {
-		const rval = await delay(42, 1)
-		expect(rval).toBe(42)
-	})
-})
-
-describe("solid", () => {
-	it("await createRoot returns the result the async function", async () => {
-		let count = 0
-		await sleep(0)
-		const rval = await createRoot(async () => {
-			await sleep(0)
-			count++
-			return await delay(42, 1)
-		})
-		expect(rval).toBe(42)
-		expect(count).toBe(1)
-	})
-
-	it("sets and gets", () => {
-		const [get, set] = createSignal(0)
-
-		expect(get()).toBe(0)
-		set(1)
-		expect(get()).toBe(1)
-	})
-
-	it("runs an effect whenn the signal value change", () => {
-		const [get, set] = createSignal(0)
-		let count = 0
-		createEffect(() => {
-			count++
-			get()
-		})
-		expect(count).toBe(1)
-		set(1)
-		expect(count).toBe(2)
-		set(1)
-		expect(count).toBe(2)
-		set(0)
-		expect(count).toBe(3)
-	})
-
-	it("runs an effect on a derived signal, when the underlying signal changes", () => {
-		const [get, set] = createSignal(0)
-		const derived = () => get() * 2
-		let count = 0
-		createEffect(() => {
-			count++
-			derived()
-		})
-		expect(count).toBe(1)
-		set(1)
-		expect(count).toBe(2)
-		set(1)
-		expect(count).toBe(2)
-		set(0)
-		expect(count).toBe(3)
-	})
-
-	it("signal values are not deep diffed for equality", () => {
-		const [get, set] = createSignal({ a: 0, b: [1, 2, 3], c: { d: 4 } })
-		let count = 0
-		createEffect(() => {
-			count++
-			get()
-		})
-		expect(count).toBe(1)
-		set({ a: 0, b: [1, 2, 3], c: { d: 5 } })
-		expect(count).toBe(2)
-		set({ a: 0, b: [1, 2, 3], c: { d: 5 } })
-		expect(count).toBe(3)
-		set({ a: 0, b: [1, 2, 3], c: { d: 4 } })
-		expect(count).toBe(4)
-	})
-
-	it("await in effect prevents signal from being tracked", async () => {
-		const [get, set] = createSignal(0)
-		let count = 0
-		// effect bumps count - depends on get() - never gets called again
-		createEffect(async () => {
-			count++
-			await sleep(0)
-			get()
-		})
-		expect(count).toBe(1)
-		set(1)
-		expect(count).toBe(1)
-		await sleep(0)
-		set(2)
-		expect(count).toBe(1)
-	})
-
-	it("signal behind function call is tracked - same as derived", async () => {
-		const [get, set] = createSignal(0)
-		let count = 0
-		const fn = () => get()
-		createEffect(async () => {
-			count++
-			fn()
-		})
-		expect(count).toBe(1)
-		set(1)
-		expect(count).toBe(2)
-	})
-
-	it("Resource async fetch is triggered by signals, and works in effects", async () => {
-		const [get, set] = createSignal<number>(0)
-
-		const [resource] = createResource(get, async (v) => {
-			return (await delay(v, 10)) as number
-		})
-
-		let count = 0
-		createEffect(() => {
-			count++
-			resource()
-		})
-
-		expect(resource.loading).toBe(true)
-		expect(resource()).toBe(undefined)
-		expect(count).toBe(1)
-
-		await sleep(20)
-		expect(resource.loading).toBe(false)
-		expect(resource()).toBe(0)
-		expect(count).toBe(2)
-
-		set(42)
-		expect(resource.loading).toBe(true)
-		expect(resource()).toBe(0)
-		expect(count).toBe(2)
-
-		await sleep(20)
-		expect(resource.loading).toBe(false)
-		expect(resource()).toBe(42)
-		expect(count).toBe(3)
-	})
-
-	it("memoizes values and updates them when signals change", () => {
-		const [get, set] = createSignal(0)
-		let count = 0
-		const memo = createMemo(() => {
-			count++
-			return `memo = ${2 * get()}`
-		})
-		expect(count).toBe(1)
-		expect(memo()).toBe("memo = 0")
-		expect(count).toBe(1)
-		expect(memo()).toBe("memo = 0")
-		expect(count).toBe(1)
-		set(1)
-		expect(count).toBe(2)
-		expect(memo()).toBe("memo = 2")
-		set(1)
-		expect(count).toBe(2)
-		expect(memo()).toBe("memo = 2")
-		expect(count).toBe(2)
-		expect(memo()).toBe("memo = 2")
-		set(1000)
-		expect(count).toBe(3)
-		expect(memo()).toBe("memo = 2000")
-	})
-})
-
-describe("solid", () => {
-	it("solid reactive map allows to use untrack", () => {
-		// @ts-expect-error -- ReactiveMap seem to have problems type arguments here
-		const reactiveMap = new ReactiveMap<string, any>()
-		const [plainSignal, setPlainSignal] = createSignal(0)
-
-		let shouldTriggerOnBoth = -1
-		createEffect(() => {
-			shouldTriggerOnBoth++
-			reactiveMap.values()
-			plainSignal()
-		})
-
-		let shouldTriggerOnReactiveMapOnly = -1
-		createEffect(() => {
-			shouldTriggerOnReactiveMapOnly++
-			reactiveMap.values()
-			untrack(() => plainSignal())
-		})
-
-		let shouldTriggerOnPlainSignalOnly = -1
-		createEffect(() => {
-			shouldTriggerOnPlainSignalOnly++
-			untrack(() => reactiveMap.values())
-			plainSignal()
-		})
-
-		expect(shouldTriggerOnBoth).toBe(0)
-		expect(shouldTriggerOnReactiveMapOnly).toBe(0)
-		expect(shouldTriggerOnPlainSignalOnly).toBe(0)
-
-		setPlainSignal(1)
-
-		expect(shouldTriggerOnBoth).toBe(1)
-		expect(shouldTriggerOnReactiveMapOnly).toBe(0)
-		expect(shouldTriggerOnPlainSignalOnly).toBe(1)
-
-		reactiveMap.set("a", "a")
-
-		expect(shouldTriggerOnBoth).toBe(2)
-		expect(shouldTriggerOnReactiveMapOnly).toBe(1)
-		expect(shouldTriggerOnPlainSignalOnly).toBe(1)
-	})
-})

package/src/reactivity/solid.ts

@@ -1,42 +0,0 @@
-import {
-	createSignal as _createSignal,
-	createMemo as _createMemo,
-	createRoot as _createRoot,
-	createEffect as _createEffect,
-	createResource as _createResource,
-	untrack as _untrack,
-	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 createResource = _createResource as typeof import("solid-js")["createResource"]
-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"]
-const untrack = _untrack as typeof import("solid-js")["untrack"]
-
-export {
-	createSignal,
-	createMemo,
-	createRoot,
-	createEffect,
-	createResource,
-	observable,
-	from,
-	batch,
-	getListener,
-	onCleanup,
-	untrack,
-	DEV,
-}

package/src/reactivity/trigger.ts

@@ -1,46 +0,0 @@
-// @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/cache.ts

@@ -1,89 +0,0 @@
-import type { NodeishFilesystemSubset } from "@inlang/plugin"
-import { type Result, tryCatch } from "@inlang/result"
-
-function escape(url: string) {
-	const bytes = new TextEncoder().encode(url)
-
-	// 64-bit FNV1a hash to make the file-names shorter
-	// https://en.wikipedia.org/wiki/FNV-1a
-	const hash = bytes.reduce(
-		(hash, byte) => BigInt.asUintN(64, (hash ^ BigInt(byte)) * 1_099_511_628_211n),
-		14_695_981_039_346_656_037n
-	)
-
-	return hash.toString(36)
-}
-
-async function readModuleFromCache(
-	moduleURI: string,
-	projectPath: string,
-	readFile: NodeishFilesystemSubset["readFile"]
-): Promise<Result<string, Error>> {
-	const moduleHash = escape(moduleURI)
-	const filePath = projectPath + `/cache/modules/${moduleHash}`
-
-	return await tryCatch(async () => await readFile(filePath, { encoding: "utf-8" }))
-}
-
-async function writeModuleToCache(
-	moduleURI: string,
-	moduleContent: string,
-	projectPath: string,
-	writeFile: NodeishFilesystemSubset["writeFile"],
-	mkdir: NodeishFilesystemSubset["mkdir"]
-): Promise<void> {
-	const moduleHash = escape(moduleURI)
-	const filePath = projectPath + `/cache/modules/${moduleHash}`
-
-	const writeFileResult = await tryCatch(() => writeFile(filePath, moduleContent))
-	if (writeFileResult.error) {
-		const dirPath = projectPath + `/cache/modules`
-		const createDirResult = await tryCatch(() => mkdir(dirPath, { recursive: true }))
-
-		// @ts-ignore - If the directory exists we can ignore this error
-		if (createDirResult.error && createDirResult.error.code !== "EEXIST")
-			throw new Error("[sdk:module-cacke] failed to create cache-directory. Path: " + dirPath, {
-				cause: createDirResult.error,
-			})
-
-		const writeFileResult = await tryCatch(() => writeFile(filePath, moduleContent))
-		if (writeFileResult.error)
-			throw new Error("[sdk:module-cacke] failed to write cache-file. Path: " + filePath, {
-				cause: writeFileResult.error,
-			})
-	}
-}
-
-/**
- * Implements a "Network-First" caching strategy.
- */
-export function withCache(
-	moduleLoader: (uri: string) => Promise<string>,
-	projectPath: string,
-	nodeishFs: Pick<NodeishFilesystemSubset, "readFile" | "writeFile" | "mkdir">
-): (uri: string) => Promise<string> {
-	return async (uri: string) => {
-		const cachePromise = readModuleFromCache(uri, projectPath, nodeishFs.readFile)
-		const loaderResult = await tryCatch(async () => await moduleLoader(uri))
-
-		if (loaderResult.error) {
-			const cacheResult = await cachePromise
-			if (!cacheResult.error) return cacheResult.data
-			else throw loaderResult.error
-		} else {
-			const moduleAsText = loaderResult.data
-			try {
-				await writeModuleToCache(
-					uri,
-					moduleAsText,
-					projectPath,
-					nodeishFs.writeFile,
-					nodeishFs.mkdir
-				)
-			} catch (error) {
-				// TODO trigger a warning
-			}
-			return moduleAsText
-		}
-	}
-}

package/src/resolve-modules/errors.ts

@@ -1,69 +0,0 @@
-import type { ValueError } from "@sinclair/typebox/errors"
-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(options: { module: string; cause?: Error }) {
-		super(
-			`Module "${options.module}" has no exports. Every module must have an "export default".`,
-			options
-		)
-		this.name = "ModuleHasNoExportsError"
-	}
-}
-
-/**
- * Error when a Module cannot be imported.
- */
-export class ModuleImportError extends ModuleError {
-	constructor(options: { module: string; cause: Error }) {
-		super(`Couldn't import the plugin "${options.module}":\n\n${options.cause}`, options)
-		this.name = "ModuleImportError"
-	}
-}
-
-export class ModuleExportIsInvalidError extends ModuleError {
-	constructor(options: { module: string; errors: ValueError[] }) {
-		super(
-			`The export(s) of "${options.module}" are invalid:\n\n${options.errors
-				.map(
-					(error) =>
-						`"${error.path}" "${JSON.stringify(error.value, undefined, 2)}": "${error.message}"`
-				)
-				.join("\n")}`,
-			options
-		)
-		this.name = "ModuleExportIsInvalidError"
-	}
-}
-
-export class ModuleSettingsAreInvalidError extends ModuleError {
-	constructor(options: { module: string; errors: ValueError[] }) {
-		super(
-			`The settings are invalid of "${options.module}" are invalid:\n\n${options.errors
-				.map(
-					(error) =>
-						`Path "${error.path}" with value "${JSON.stringify(error.value, undefined, 2)}": "${
-							error.message
-						}"`
-				)
-				.join("\n")}`,
-			options
-		)
-		this.name = "ModuleSettingsAreInvalidError"
-	}
-}

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

@@ -1,62 +0,0 @@
-// @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.mkdir("./project.inlang/cache/modules", { recursive: true })
-
-	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("/project.inlang", {
-		writeFile: fs.writeFile,
-		readFile: fs.readFile,
-		mkdir: fs.mkdir,
-	})
-
-	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)
-		}
-	})
-})

package/src/resolve-modules/import.ts

@@ -1,133 +0,0 @@
-import dedent from "dedent"
-import type { NodeishFilesystemSubset } from "@inlang/plugin"
-import { ModuleImportError } from "./errors.js"
-import { withCache } from "./cache.js"
-import { tryCatch } from "@inlang/result"
-
-/**
- * Importing ES modules either from a local path, or from a url.
- *
- * - Name the import function `_import` to avoid shadowing the
- *   native import function.
- */
-export type ImportFunction = (uri: string) => Promise<any>
-
-/**
- * Creates the import function.
- *
- * This function is required to import modules from a local path.
- *
- * @example
- *   const $import = createImport({ readFile: fs.readFile, fetch });
- *   const module = await _import('./some-module.js');
- */
-export function createImport(
-	projectPath: string,
-	nodeishFs: Pick<NodeishFilesystemSubset, "readFile" | "writeFile" | "mkdir">
-) {
-	return (uri: string) => $import(uri, projectPath, nodeishFs)
-}
-
-async function $import(
-	uri: string,
-	projectPath: string,
-	nodeishFs: Pick<NodeishFilesystemSubset, "readFile" | "writeFile" | "mkdir">
-): Promise<any> {
-	const moduleAsText = uri.startsWith("http")
-		? await withCache(readModuleFromCDN, projectPath, nodeishFs)(uri)
-		: await readModulefromDisk(uri, nodeishFs.readFile)
-
-	const moduleWithMimeType = "data:application/javascript," + encodeURIComponent(moduleAsText)
-
-	try {
-		return await import(/* @vite-ignore */ moduleWithMimeType)
-	} catch (error) {
-		if (error instanceof SyntaxError && uri.includes("jsdelivr")) {
-			error.message += dedent`\n\n
-				Are you sure that the file exists on JSDelivr?
-
-				The error indicates that the imported file does not exist on JSDelivr. For non-existent files, JSDelivr returns a 404 text that JS cannot parse as a module and throws a SyntaxError.`
-		}
-		throw new ModuleImportError({ module: uri, cause: error as Error })
-	}
-}
-
-/**
- * Tries to read the module from disk
- * @throws {ModuleImportError}
- */
-async function readModulefromDisk(
-	uri: string,
-	readFile: NodeishFilesystemSubset["readFile"]
-): Promise<string> {
-	try {
-		return await readFile(uri, { encoding: "utf-8" })
-	} catch (error) {
-		throw new ModuleImportError({ module: uri, cause: error as Error })
-	}
-}
-
-/**
- * Reads a module from a CDN.
- * Tries to read local cache first.
- *
- * @param uri A valid URL
- * @throws {ModuleImportError}
- */
-async function readModuleFromCDN(uri: string): Promise<string> {
-	if (!isValidUrl(uri))
-		throw new ModuleImportError({ module: uri, cause: new Error("Malformed URL") })
-
-	const result = await tryCatch(async () => await fetch(uri))
-	if (result.error) {
-		throw new ModuleImportError({
-			module: uri,
-			cause: result.error,
-		})
-	}
-
-	const response = result.data
-	if (!response.ok) {
-		throw new ModuleImportError({
-			module: uri,
-			cause: new Error(
-				`Failed to fetch module. HTTP status: ${response.status}, Message: ${response.statusText}`
-			),
-		})
-	}
-
-	const JS_CONTENT_TYPES = [
-		"application/javascript",
-		"text/javascript",
-		"application/x-javascript",
-		"text/x-javascript",
-	]
-
-	// if there is no content-type header, assume it's a JavaScript module & hope for the best
-	const contentType = response.headers.get("content-type")?.toLowerCase()
-	if (contentType && !JS_CONTENT_TYPES.some((knownType) => contentType.includes(knownType))) {
-		throw new ModuleImportError({
-			module: uri,
-			cause: new Error(`Server responded with ${contentType} insetad of a JavaScript module`),
-		})
-	}
-
-	return await response.text()
-}
-
-function isValidUrl(url: string) {
-	// This dance is necessary to both support a fallback in case URL.canParse
-	// is not present (like in vitest), and also appease typescript
-	const URLConstructor = URL
-	if ("canParse" in URL) {
-		return URL.canParse(url)
-	}
-
-	try {
-		new URLConstructor(url)
-		return true
-	} catch (e) {
-		console.warn(`Invalid URL: ${url}`)
-		return false
-	}
-}

package/src/resolve-modules/index.ts

@@ -1,2 +0,0 @@
-export { resolveModules } from "./resolveModules.js"
-export { type ImportFunction, createImport } from "./import.js"

package/src/resolve-modules/message-lint-rules/errors.ts

@@ -1,9 +0,0 @@
-import type { MessageLintRule } from "@inlang/message-lint-rule"
-import type { ValueError } from "@sinclair/typebox/errors"
-
-export class MessageLintRuleIsInvalidError extends Error {
-	constructor(options: { id: MessageLintRule["id"]; errors: ValueError[] }) {
-		super(`The message lint rule "${options.id}" is invalid:\n\n${options.errors.join("\n")}`)
-		this.name = "MessageLintRuleIsInvalidError"
-	}
-}

package/src/resolve-modules/message-lint-rules/resolveMessageLintRules.ts

@@ -1,27 +0,0 @@
-import { Value } from "@sinclair/typebox/value"
-import { MessageLintRule } from "@inlang/message-lint-rule"
-import { MessageLintRuleIsInvalidError } from "./errors.js"
-
-export const resolveMessageLintRules = (args: { messageLintRules: Array<MessageLintRule> }) => {
-	const result = {
-		data: [] as Array<MessageLintRule>,
-		errors: [] as MessageLintRuleIsInvalidError[],
-	}
-	for (const rule of args.messageLintRules) {
-		if (Value.Check(MessageLintRule, rule) === false) {
-			const errors = [...Value.Errors(MessageLintRule, rule)]
-			result.errors.push(
-				new MessageLintRuleIsInvalidError({
-					// @ts-ignore
-					id: rule.id,
-					errors,
-				})
-			)
-			continue
-		} else {
-			result.data.push(rule)
-		}
-	}
-
-	return result
-}