@inlang/sdk 0.11.0 → 0.12.0

package/dist/createNodeishFsWithAbsolutePaths.d.ts

@@ -0,0 +1,13 @@
+import type { NodeishFilesystemSubset } from "@inlang/plugin";
+export declare const isAbsolutePath: (path: string) => boolean;
+/**
+ * Wraps the nodeish filesystem subset with a function that intercepts paths
+ * and prepends the base path.
+ *
+ * The paths are resolved from the `settingsFilePath` argument.
+ */
+export declare const createNodeishFsWithAbsolutePaths: (args: {
+    settingsFilePath: string;
+    nodeishFs: NodeishFilesystemSubset;
+}) => NodeishFilesystemSubset;
+//# sourceMappingURL=createNodeishFsWithAbsolutePaths.d.ts.map

package/dist/createNodeishFsWithAbsolutePaths.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createNodeishFsWithAbsolutePaths.d.ts","sourceRoot":"","sources":["../src/createNodeishFsWithAbsolutePaths.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,gBAAgB,CAAA;AAG7D,eAAO,MAAM,cAAc,SAAU,MAAM,YAAwB,CAAA;AAEnE;;;;;GAKG;AACH,eAAO,MAAM,gCAAgC,SAAU;IACtD,gBAAgB,EAAE,MAAM,CAAA;IACxB,SAAS,EAAE,uBAAuB,CAAA;CAClC,KAAG,uBAyBH,CAAA"}

package/dist/createNodeishFsWithAbsolutePaths.js

@@ -0,0 +1,29 @@
+import { normalizePath } from "@lix-js/fs";
+export const isAbsolutePath = (path) => /^[/\\]/.test(path);
+/**
+ * Wraps the nodeish filesystem subset with a function that intercepts paths
+ * and prepends the base path.
+ *
+ * The paths are resolved from the `settingsFilePath` argument.
+ */
+export const createNodeishFsWithAbsolutePaths = (args) => {
+    if (!isAbsolutePath(args.settingsFilePath)) {
+        throw new Error("The argument `settingsFilePath` must be an absolute path.");
+    }
+    // get the base path of the settings file by
+    // removing the file name from the path
+    const bathPath = args.settingsFilePath.split("/").slice(0, -1).join("/");
+    const makeAbsolute = (path) => {
+        if (isAbsolutePath(path)) {
+            return path;
+        }
+        return normalizePath(bathPath + "/" + path);
+    };
+    return {
+        // @ts-expect-error
+        readFile: (path, options) => args.nodeishFs.readFile(makeAbsolute(path), options),
+        readdir: (path) => args.nodeishFs.readdir(makeAbsolute(path)),
+        mkdir: (path) => args.nodeishFs.mkdir(makeAbsolute(path)),
+        writeFile: (path, data) => args.nodeishFs.writeFile(makeAbsolute(path), data),
+    };
+};

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

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

package/dist/createNodeishFsWithAbsolutePaths.test.js

@@ -0,0 +1,37 @@
+import { it, expect, vi } from "vitest";
+import { createNodeishFsWithAbsolutePaths } from "./createNodeishFsWithAbsolutePaths.js";
+it("throws an error if settingsFilePath is not an absolute path", () => {
+    const relativePath = "relative/path";
+    expect(() => createNodeishFsWithAbsolutePaths({ settingsFilePath: relativePath, nodeishFs: {} })).toThrow();
+});
+it("intercepts paths correctly for readFile", async () => {
+    const settingsFilePath = `/Users/samuel/Documents/paraglide/example/project.inlang.json`;
+    const filePaths = [
+        ["file.txt", `/Users/samuel/Documents/paraglide/example/file.txt`],
+        ["./file.txt", `/Users/samuel/Documents/paraglide/example/file.txt`],
+        ["./folder/file.txt", `/Users/samuel/Documents/paraglide/example/folder/file.txt`],
+        ["../file.txt", `/Users/samuel/Documents/paraglide/file.txt`],
+        ["../folder/file.txt", `/Users/samuel/Documents/paraglide/folder/file.txt`],
+        ["../../file.txt", `/Users/samuel/Documents/file.txt`],
+        ["../../../file.txt", `/Users/samuel/file.txt`],
+    ];
+    const mockNodeishFs = {
+        readFile: vi.fn(),
+        readdir: vi.fn(),
+        mkdir: vi.fn(),
+        writeFile: vi.fn(),
+    };
+    const interceptedFs = createNodeishFsWithAbsolutePaths({
+        settingsFilePath,
+        nodeishFs: mockNodeishFs,
+    });
+    for (const [path, expectedPath] of filePaths) {
+        for (const fn of Object.keys(mockNodeishFs)) {
+            // @ts-expect-error
+            await interceptedFs[fn](path);
+            // @ts-expect-error
+            // expect the first argument to be the expectedPath
+            expect(mockNodeishFs[fn].mock.lastCall[0]).toBe(expectedPath);
+        }
+    }
+});

package/dist/errors.d.ts

@@ -1,4 +1,9 @@
 import type { ValueError } from "@sinclair/typebox/errors";
+export declare class LoadProjectInvalidArgument extends Error {
+    constructor(message: string, options: {
+        argument: string;
+    });
+}
 export declare class ProjectSettingsInvalidError extends Error {
     constructor(options: {
         errors: ValueError[];

package/dist/errors.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAE1D,qBAAa,2BAA4B,SAAQ,KAAK;gBACzC,OAAO,EAAE;QAAE,MAAM,EAAE,UAAU,EAAE,CAAA;KAAE;CAQ7C;AAED,qBAAa,kCAAmC,SAAQ,KAAK;gBAChD,OAAO,EAAE;QAAE,KAAK,EAAE,YAAY,CAAC,OAAO,CAAC,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE;CAOnE;AAED,qBAAa,gCAAiC,SAAQ,KAAK;gBAC9C,OAAO,EAAE;QAAE,KAAK,CAAC,EAAE,YAAY,CAAC,OAAO,CAAC,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE;CAIpE;AAED,qBAAa,uBAAwB,SAAQ,KAAK;gBACrC,OAAO,EAAE;QAAE,KAAK,EAAE,YAAY,CAAC,OAAO,CAAC,CAAA;KAAE;CAIrD;AAED,qBAAa,uBAAwB,SAAQ,KAAK;gBACrC,OAAO,EAAE;QAAE,KAAK,EAAE,YAAY,CAAC,OAAO,CAAC,CAAA;KAAE;CAIrD"}
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAE1D,qBAAa,0BAA2B,SAAQ,KAAK;gBACxC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAA;KAAE;CAI1D;AAED,qBAAa,2BAA4B,SAAQ,KAAK;gBACzC,OAAO,EAAE;QAAE,MAAM,EAAE,UAAU,EAAE,CAAA;KAAE;CAQ7C;AAED,qBAAa,kCAAmC,SAAQ,KAAK;gBAChD,OAAO,EAAE;QAAE,KAAK,EAAE,YAAY,CAAC,OAAO,CAAC,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE;CAOnE;AAED,qBAAa,gCAAiC,SAAQ,KAAK;gBAC9C,OAAO,EAAE;QAAE,KAAK,CAAC,EAAE,YAAY,CAAC,OAAO,CAAC,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE;CAIpE;AAED,qBAAa,uBAAwB,SAAQ,KAAK;gBACrC,OAAO,EAAE;QAAE,KAAK,EAAE,YAAY,CAAC,OAAO,CAAC,CAAA;KAAE;CAIrD;AAED,qBAAa,uBAAwB,SAAQ,KAAK;gBACrC,OAAO,EAAE;QAAE,KAAK,EAAE,YAAY,CAAC,OAAO,CAAC,CAAA;KAAE;CAIrD"}

package/dist/errors.js

@@ -1,3 +1,9 @@
+export class LoadProjectInvalidArgument extends Error {
+    constructor(message, options) {
+        super(`The argument "${options.argument}" of loadProject() is invalid: ${message}`);
+        this.name = "LoadProjectInvalidArgument";
+    }
+}
 export class ProjectSettingsInvalidError extends Error {
     constructor(options) {
         super(`The project settings are invalid:\n\n${options.errors

package/dist/loadProject.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"loadProject.d.ts","sourceRoot":"","sources":["../src/loadProject.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACX,aAAa,EAGb,YAAY,EACZ,MAAM,UAAU,CAAA;AACjB,OAAO,EAAE,KAAK,cAAc,EAAkB,MAAM,4BAA4B,CAAA;AAahF,OAAO,EAA4B,KAAK,uBAAuB,EAAE,MAAM,0BAA0B,CAAA;AAOjG;;;;;;;;;GASG;AACH,eAAO,MAAM,WAAW;sBACL,MAAM;eACb,uBAAuB;;qBAElB,MAAM,SAAS,OAAO,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI;MAC5D,QAAQ,aAAa,CA4LxB,CAAA;AAqGD,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,CAQtE"}
+{"version":3,"file":"loadProject.d.ts","sourceRoot":"","sources":["../src/loadProject.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACX,aAAa,EAGb,YAAY,EACZ,MAAM,UAAU,CAAA;AACjB,OAAO,EAAE,KAAK,cAAc,EAAkB,MAAM,4BAA4B,CAAA;AAchF,OAAO,EAA4B,KAAK,uBAAuB,EAAE,MAAM,0BAA0B,CAAA;AAUjG;;;;;;;;;GASG;AACH,eAAO,MAAM,WAAW;sBACL,MAAM;eACb,uBAAuB;;qBAElB,MAAM,SAAS,OAAO,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI;MAC5D,QAAQ,aAAa,CAkMxB,CAAA;AAqGD,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,CAQtE"}

package/dist/loadProject.js

@@ -1,6 +1,6 @@
 import { resolveModules } from "./resolve-modules/index.js";
 import { TypeCompiler } from "@sinclair/typebox/compiler";
-import { ProjectSettingsFileJSONSyntaxError, ProjectSettingsFileNotFoundError, ProjectSettingsInvalidError, PluginLoadMessagesError, PluginSaveMessagesError, } from "./errors.js";
+import { ProjectSettingsFileJSONSyntaxError, ProjectSettingsFileNotFoundError, ProjectSettingsInvalidError, PluginLoadMessagesError, PluginSaveMessagesError, LoadProjectInvalidArgument, } from "./errors.js";
 import { createRoot, createSignal, createEffect } from "./reactivity/solid.js";
 import { createMessagesQuery } from "./createMessagesQuery.js";
 import { debounce } from "throttle-debounce";
@@ -8,7 +8,7 @@ import { createMessageLintReportsQuery } from "./createMessageLintReportsQuery.j
 import { ProjectSettings, Message } from "./versionedInterfaces.js";
 import { tryCatch } from "@inlang/result";
 import { migrateIfOutdated } from "@inlang/project-settings/migration";
-import { createNodeishFsWithAbsolutePaths } from "./resolve-modules/createNodeishFsWithAbsolutePaths.js";
+import { createNodeishFsWithAbsolutePaths, isAbsolutePath, } from "./createNodeishFsWithAbsolutePaths.js";
 const settingsCompiler = TypeCompiler.Compile(ProjectSettings);
 /**
  * Creates an inlang instance.
@@ -21,13 +21,17 @@ const settingsCompiler = TypeCompiler.Compile(ProjectSettings);
  *
  */
 export const loadProject = async (args) => {
+    // -- validation --------------------------------------------------------
+    //! the only place where throwing is acceptable because the project
+    //! won't even be loaded. do not throw anywhere else. otherwise, apps
+    //! can't handle errors gracefully.
+    if (!isAbsolutePath(args.settingsFilePath)) {
+        throw new LoadProjectInvalidArgument(`Expected an absolute path but received "${args.settingsFilePath}".`, { argument: "settingsFilePath" });
+    }
+    // -- load project ------------------------------------------------------
     return await createRoot(async () => {
         const [initialized, markInitAsComplete, markInitAsFailed] = createAwaitable();
-        // -- absolute path env -----------------------------------------------
-        const nodeishFs = createNodeishFsWithAbsolutePaths({
-            nodeishFs: args.nodeishFs,
-            basePath: args.settingsFilePath.replace(/(.*?)[^/]*\..*$/, "$1"), // get directory of settings file
-        });
+        const nodeishFs = createNodeishFsWithAbsolutePaths(args);
         // -- settings ------------------------------------------------------------
         const [settings, _setSettings] = createSignal();
         createEffect(() => {

package/dist/loadProject.test.js

@@ -1,9 +1,10 @@
 /* eslint-disable @typescript-eslint/no-non-null-assertion */
 import { describe, it, expect, vi } from "vitest";
 import { loadProject } from "./loadProject.js";
-import { ProjectSettingsFileJSONSyntaxError, ProjectSettingsFileNotFoundError, ProjectSettingsInvalidError, } from "./errors.js";
+import { LoadProjectInvalidArgument, ProjectSettingsFileJSONSyntaxError, ProjectSettingsFileNotFoundError, ProjectSettingsInvalidError, } from "./errors.js";
 import { createNodeishMemoryFs } from "@lix-js/fs";
 import { createMessage } from "./test-utilities/createMessage.js";
+import { tryCatch } from "@inlang/result";
 // ------------------------------------------------------------------------------------------------
 const getValue = (subscribable) => {
     let value;
@@ -80,6 +81,16 @@ const _import = async (name) => ({
 });
 // ------------------------------------------------------------------------------------------------
 describe("initialization", () => {
+    it("should throw if settingsFilePath is not an absolute path", async () => {
+        const fs = createNodeishMemoryFs();
+        const result = await tryCatch(() => loadProject({
+            settingsFilePath: "relative/path",
+            nodeishFs: fs,
+            _import,
+        }));
+        expect(result.error).toBeInstanceOf(LoadProjectInvalidArgument);
+        expect(result.data).toBeUndefined();
+    });
     describe("settings", () => {
         it("should return an error if settings file is not found", async () => {
             const fs = createNodeishMemoryFs();

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@inlang/sdk",
 	"type": "module",
-	"version": "0.11.0",
+	"version": "0.12.0",
 	"license": "Apache-2.0",
 	"publishConfig": {
 		"access": "public"

package/src/createNodeishFsWithAbsolutePaths.test.ts

@@ -0,0 +1,47 @@
+import { it, expect, vi } from "vitest"
+import { createNodeishFsWithAbsolutePaths } from "./createNodeishFsWithAbsolutePaths.js"
+import type { NodeishFilesystemSubset } from "./versionedInterfaces.js"
+
+it("throws an error if settingsFilePath is not an absolute path", () => {
+	const relativePath = "relative/path"
+
+	expect(() =>
+		createNodeishFsWithAbsolutePaths({ settingsFilePath: relativePath, nodeishFs: {} as any })
+	).toThrow()
+})
+
+it("intercepts paths correctly for readFile", async () => {
+	const settingsFilePath = `/Users/samuel/Documents/paraglide/example/project.inlang.json`
+
+	const filePaths = [
+		["file.txt", `/Users/samuel/Documents/paraglide/example/file.txt`],
+		["./file.txt", `/Users/samuel/Documents/paraglide/example/file.txt`],
+		["./folder/file.txt", `/Users/samuel/Documents/paraglide/example/folder/file.txt`],
+		["../file.txt", `/Users/samuel/Documents/paraglide/file.txt`],
+		["../folder/file.txt", `/Users/samuel/Documents/paraglide/folder/file.txt`],
+		["../../file.txt", `/Users/samuel/Documents/file.txt`],
+		["../../../file.txt", `/Users/samuel/file.txt`],
+	]
+
+	const mockNodeishFs = {
+		readFile: vi.fn(),
+		readdir: vi.fn(),
+		mkdir: vi.fn(),
+		writeFile: vi.fn(),
+	} satisfies Record<keyof NodeishFilesystemSubset, any>
+
+	const interceptedFs = createNodeishFsWithAbsolutePaths({
+		settingsFilePath,
+		nodeishFs: mockNodeishFs,
+	})
+
+	for (const [path, expectedPath] of filePaths) {
+		for (const fn of Object.keys(mockNodeishFs)) {
+			// @ts-expect-error
+			await interceptedFs[fn](path)
+			// @ts-expect-error
+			// expect the first argument to be the expectedPath
+			expect(mockNodeishFs[fn].mock.lastCall[0]).toBe(expectedPath)
+		}
+	}
+})

package/src/createNodeishFsWithAbsolutePaths.ts

@@ -0,0 +1,40 @@
+import type { NodeishFilesystemSubset } from "@inlang/plugin"
+import { normalizePath } from "@lix-js/fs"
+
+export const isAbsolutePath = (path: string) => /^[/\\]/.test(path)
+
+/**
+ * Wraps the nodeish filesystem subset with a function that intercepts paths
+ * and prepends the base path.
+ *
+ * The paths are resolved from the `settingsFilePath` argument.
+ */
+export const createNodeishFsWithAbsolutePaths = (args: {
+	settingsFilePath: string
+	nodeishFs: NodeishFilesystemSubset
+}): NodeishFilesystemSubset => {
+	if (!isAbsolutePath(args.settingsFilePath)) {
+		throw new Error("The argument `settingsFilePath` must be an absolute path.")
+	}
+
+	// get the base path of the settings file by
+	// removing the file name from the path
+	const bathPath = args.settingsFilePath.split("/").slice(0, -1).join("/")
+
+	const makeAbsolute = (path: string) => {
+		if (isAbsolutePath(path)) {
+			return path
+		}
+
+		return normalizePath(bathPath + "/" + path)
+	}
+
+	return {
+		// @ts-expect-error
+		readFile: (path: string, options: { encoding: "utf-8" | "binary" }) =>
+			args.nodeishFs.readFile(makeAbsolute(path), options),
+		readdir: (path: string) => args.nodeishFs.readdir(makeAbsolute(path)),
+		mkdir: (path: string) => args.nodeishFs.mkdir(makeAbsolute(path)),
+		writeFile: (path: string, data: string) => args.nodeishFs.writeFile(makeAbsolute(path), data),
+	}
+}

package/src/errors.ts

@@ -1,5 +1,12 @@
 import type { ValueError } from "@sinclair/typebox/errors"
 
+export class LoadProjectInvalidArgument extends Error {
+	constructor(message: string, options: { argument: string }) {
+		super(`The argument "${options.argument}" of loadProject() is invalid: ${message}`)
+		this.name = "LoadProjectInvalidArgument"
+	}
+}
+
 export class ProjectSettingsInvalidError extends Error {
 	constructor(options: { errors: ValueError[] }) {
 		super(

package/src/loadProject.test.ts

@@ -5,12 +5,14 @@ import type { ProjectSettings, Plugin, MessageLintRule, Message } from "./versio
 import type { ImportFunction } from "./resolve-modules/index.js"
 import type { InlangModule } from "@inlang/module"
 import {
+	LoadProjectInvalidArgument,
 	ProjectSettingsFileJSONSyntaxError,
 	ProjectSettingsFileNotFoundError,
 	ProjectSettingsInvalidError,
 } from "./errors.js"
 import { createNodeishMemoryFs } from "@lix-js/fs"
 import { createMessage } from "./test-utilities/createMessage.js"
+import { tryCatch } from "@inlang/result"
 
 // ------------------------------------------------------------------------------------------------
 
@@ -97,6 +99,20 @@ const _import: ImportFunction = async (name) =>
 // ------------------------------------------------------------------------------------------------
 
 describe("initialization", () => {
+	it("should throw if settingsFilePath is not an absolute path", async () => {
+		const fs = createNodeishMemoryFs()
+
+		const result = await tryCatch(() =>
+			loadProject({
+				settingsFilePath: "relative/path",
+				nodeishFs: fs,
+				_import,
+			})
+		)
+		expect(result.error).toBeInstanceOf(LoadProjectInvalidArgument)
+		expect(result.data).toBeUndefined()
+	})
+
 	describe("settings", () => {
 		it("should return an error if settings file is not found", async () => {
 			const fs = createNodeishMemoryFs()

package/src/loadProject.ts

@@ -13,6 +13,7 @@ import {
 	ProjectSettingsInvalidError,
 	PluginLoadMessagesError,
 	PluginSaveMessagesError,
+	LoadProjectInvalidArgument,
 } from "./errors.js"
 import { createRoot, createSignal, createEffect } from "./reactivity/solid.js"
 import { createMessagesQuery } from "./createMessagesQuery.js"
@@ -21,7 +22,10 @@ import { createMessageLintReportsQuery } from "./createMessageLintReportsQuery.j
 import { ProjectSettings, Message, type NodeishFilesystemSubset } from "./versionedInterfaces.js"
 import { tryCatch, type Result } from "@inlang/result"
 import { migrateIfOutdated } from "@inlang/project-settings/migration"
-import { createNodeishFsWithAbsolutePaths } from "./resolve-modules/createNodeishFsWithAbsolutePaths.js"
+import {
+	createNodeishFsWithAbsolutePaths,
+	isAbsolutePath,
+} from "./createNodeishFsWithAbsolutePaths.js"
 
 const settingsCompiler = TypeCompiler.Compile(ProjectSettings)
 
@@ -41,15 +45,21 @@ export const loadProject = async (args: {
 	_import?: ImportFunction
 	_capture?: (id: string, props: Record<string, unknown>) => void
 }): Promise<InlangProject> => {
+	// -- validation --------------------------------------------------------
+	//! the only place where throwing is acceptable because the project
+	//! won't even be loaded. do not throw anywhere else. otherwise, apps
+	//! can't handle errors gracefully.
+	if (!isAbsolutePath(args.settingsFilePath)) {
+		throw new LoadProjectInvalidArgument(
+			`Expected an absolute path but received "${args.settingsFilePath}".`,
+			{ argument: "settingsFilePath" }
+		)
+	}
+
+	// -- load project ------------------------------------------------------
 	return await createRoot(async () => {
 		const [initialized, markInitAsComplete, markInitAsFailed] = createAwaitable()
-
-		// -- absolute path env -----------------------------------------------
-
-		const nodeishFs = createNodeishFsWithAbsolutePaths({
-			nodeishFs: args.nodeishFs,
-			basePath: args.settingsFilePath.replace(/(.*?)[^/]*\..*$/, "$1"), // get directory of settings file
-		})
+		const nodeishFs = createNodeishFsWithAbsolutePaths(args)
 
 		// -- settings ------------------------------------------------------------
 
@@ -338,5 +348,3 @@ export function createSubscribable<T>(signal: () => T): Subscribable<T> {
 		},
 	})
 }
-
-

package/dist/resolve-modules/createNodeishFsWithAbsolutePaths.d.ts

@@ -1,6 +0,0 @@
-import type { NodeishFilesystemSubset } from "@inlang/plugin";
-export declare const createNodeishFsWithAbsolutePaths: (args: {
-    basePath: string;
-    nodeishFs: NodeishFilesystemSubset;
-}) => NodeishFilesystemSubset;
-//# sourceMappingURL=createNodeishFsWithAbsolutePaths.d.ts.map

package/dist/resolve-modules/createNodeishFsWithAbsolutePaths.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"createNodeishFsWithAbsolutePaths.d.ts","sourceRoot":"","sources":["../../src/resolve-modules/createNodeishFsWithAbsolutePaths.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,gBAAgB,CAAA;AAG7D,eAAO,MAAM,gCAAgC,SAAU;IACtD,QAAQ,EAAE,MAAM,CAAA;IAChB,SAAS,EAAE,uBAAuB,CAAA;CAClC,KAAG,uBAuBH,CAAA"}

package/dist/resolve-modules/createNodeishFsWithAbsolutePaths.js

@@ -1,20 +0,0 @@
-import { normalizePath } from "@lix-js/fs";
-export const createNodeishFsWithAbsolutePaths = (args) => {
-    const isAbsolutePath = (path) => /^[/\\]/.test(path);
-    if (!isAbsolutePath(args.basePath)) {
-        throw new Error("The argument `settingsFilePath` of `loadProject()` must be an absolute path.");
-    }
-    const intercept = (path) => {
-        if (isAbsolutePath(path)) {
-            return path;
-        }
-        return normalizePath(args.basePath + "/" + path);
-    };
-    return {
-        // @ts-expect-error
-        readFile: (path, options) => args.nodeishFs.readFile(intercept(path), options),
-        readdir: (path) => args.nodeishFs.readdir(intercept(path)),
-        mkdir: (path) => args.nodeishFs.mkdir(intercept(path)),
-        writeFile: (path, data) => args.nodeishFs.writeFile(intercept(path), data),
-    };
-};

package/dist/resolve-modules/createNodeishFsWithAbsolutePaths.test.d.ts.map

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

package/dist/resolve-modules/createNodeishFsWithAbsolutePaths.test.js

@@ -1,85 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { createNodeishFsWithAbsolutePaths } from "./createNodeishFsWithAbsolutePaths.js";
-describe("createNodeishFsWithAbsolutePaths", () => {
-    it("throws an error if basePath is not an absolute path", () => {
-        const invalidBasePath = "relative/path";
-        const nodeishFs = {
-            // @ts-expect-error
-            readFile: async () => Promise.resolve(new Uint8Array(0)),
-            readdir: async () => Promise.resolve([]),
-            mkdir: async () => Promise.resolve(""),
-            writeFile: async () => Promise.resolve(),
-        };
-        expect(() => createNodeishFsWithAbsolutePaths({ basePath: invalidBasePath, nodeishFs })).toThrowError("The argument `settingsFilePath` of `loadProject()` must be an absolute path.");
-    });
-    it("intercepts paths correctly for readFile", async () => {
-        const basePath = "/absolute/path";
-        const filePath = "file.txt";
-        const expectedPath = "/absolute/path/file.txt";
-        const nodeishFs = {
-            // @ts-expect-error
-            readFile: async (path) => {
-                expect(path).toBe(expectedPath);
-                return Promise.resolve(new Uint8Array(0));
-            },
-            readdir: async () => Promise.resolve([]),
-            mkdir: async () => Promise.resolve(""),
-            writeFile: async () => Promise.resolve(),
-        };
-        const interceptedFs = createNodeishFsWithAbsolutePaths({ basePath, nodeishFs });
-        await interceptedFs.readFile(filePath, { encoding: "utf-8" });
-    });
-    it("intercepts paths correctly for readdir", async () => {
-        const basePath = "/absolute/path";
-        const dirPath = "dir";
-        const expectedPath = "/absolute/path/dir";
-        const nodeishFs = {
-            // @ts-expect-error
-            readFile: async () => Promise.resolve(new Uint8Array(0)),
-            readdir: async (path) => {
-                expect(path).toBe(expectedPath);
-                return Promise.resolve([]);
-            },
-            mkdir: async () => Promise.resolve(""),
-            writeFile: async () => Promise.resolve(),
-        };
-        const interceptedFs = createNodeishFsWithAbsolutePaths({ basePath, nodeishFs });
-        await interceptedFs.readdir(dirPath);
-    });
-    it("intercepts paths correctly for mkdir", async () => {
-        const basePath = "/absolute/path";
-        const dirPath = "newDir";
-        const expectedPath = "/absolute/path/newDir";
-        const nodeishFs = {
-            // @ts-expect-error
-            readFile: async () => Promise.resolve(new Uint8Array(0)),
-            readdir: async () => Promise.resolve([]),
-            mkdir: async (path) => {
-                expect(path).toBe(expectedPath);
-                return Promise.resolve("");
-            },
-            writeFile: async () => Promise.resolve(),
-        };
-        const interceptedFs = createNodeishFsWithAbsolutePaths({ basePath, nodeishFs });
-        await interceptedFs.mkdir(dirPath);
-    });
-    it("intercepts paths correctly for writeFile", async () => {
-        const basePath = "/absolute/path";
-        const filePath = "file.txt";
-        const expectedPath = "/absolute/path/file.txt";
-        const data = "Hello, World!";
-        const nodeishFs = {
-            // @ts-expect-error
-            readFile: async () => Promise.resolve(new Uint8Array(0)),
-            readdir: async () => Promise.resolve([]),
-            mkdir: async () => Promise.resolve(""),
-            writeFile: async (path, content) => {
-                expect(path).toBe(expectedPath);
-                expect(content).toBe(data);
-                return Promise.resolve();
-            },
-        };
-        const interceptedFs = createNodeishFsWithAbsolutePaths({ basePath, nodeishFs });
-        await interceptedFs.writeFile(filePath, data);
-    });
-});

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

@@ -1,102 +0,0 @@
-import type { NodeishFilesystemSubset } from "@inlang/plugin"
-import { describe, it, expect } from "vitest"
-import { createNodeishFsWithAbsolutePaths } from "./createNodeishFsWithAbsolutePaths.js"
-
-describe("createNodeishFsWithAbsolutePaths", () => {
-	it("throws an error if basePath is not an absolute path", () => {
-		const invalidBasePath = "relative/path"
-		const nodeishFs: NodeishFilesystemSubset = {
-			// @ts-expect-error
-			readFile: async () => Promise.resolve(new Uint8Array(0)),
-			readdir: async () => Promise.resolve([]),
-			mkdir: async () => Promise.resolve(""),
-			writeFile: async () => Promise.resolve(),
-		}
-
-		expect(() =>
-			createNodeishFsWithAbsolutePaths({ basePath: invalidBasePath, nodeishFs })
-		).toThrowError("The argument `settingsFilePath` of `loadProject()` must be an absolute path.")
-	})
-
-	it("intercepts paths correctly for readFile", async () => {
-		const basePath = "/absolute/path"
-		const filePath = "file.txt"
-		const expectedPath = "/absolute/path/file.txt"
-
-		const nodeishFs: NodeishFilesystemSubset = {
-			// @ts-expect-error
-			readFile: async (path) => {
-				expect(path).toBe(expectedPath)
-				return Promise.resolve(new Uint8Array(0))
-			},
-			readdir: async () => Promise.resolve([]),
-			mkdir: async () => Promise.resolve(""),
-			writeFile: async () => Promise.resolve(),
-		}
-
-		const interceptedFs = createNodeishFsWithAbsolutePaths({ basePath, nodeishFs })
-		await interceptedFs.readFile(filePath, { encoding: "utf-8" })
-	})
-
-	it("intercepts paths correctly for readdir", async () => {
-		const basePath = "/absolute/path"
-		const dirPath = "dir"
-		const expectedPath = "/absolute/path/dir"
-
-		const nodeishFs: NodeishFilesystemSubset = {
-			// @ts-expect-error
-			readFile: async () => Promise.resolve(new Uint8Array(0)),
-			readdir: async (path) => {
-				expect(path).toBe(expectedPath)
-				return Promise.resolve([])
-			},
-			mkdir: async () => Promise.resolve(""),
-			writeFile: async () => Promise.resolve(),
-		}
-
-		const interceptedFs = createNodeishFsWithAbsolutePaths({ basePath, nodeishFs })
-		await interceptedFs.readdir(dirPath)
-	})
-
-	it("intercepts paths correctly for mkdir", async () => {
-		const basePath = "/absolute/path"
-		const dirPath = "newDir"
-		const expectedPath = "/absolute/path/newDir"
-
-		const nodeishFs: NodeishFilesystemSubset = {
-			// @ts-expect-error
-			readFile: async () => Promise.resolve(new Uint8Array(0)),
-			readdir: async () => Promise.resolve([]),
-			mkdir: async (path) => {
-				expect(path).toBe(expectedPath)
-				return Promise.resolve("")
-			},
-			writeFile: async () => Promise.resolve(),
-		}
-
-		const interceptedFs = createNodeishFsWithAbsolutePaths({ basePath, nodeishFs })
-		await interceptedFs.mkdir(dirPath)
-	})
-
-	it("intercepts paths correctly for writeFile", async () => {
-		const basePath = "/absolute/path"
-		const filePath = "file.txt"
-		const expectedPath = "/absolute/path/file.txt"
-		const data = "Hello, World!"
-
-		const nodeishFs: NodeishFilesystemSubset = {
-			// @ts-expect-error
-			readFile: async () => Promise.resolve(new Uint8Array(0)),
-			readdir: async () => Promise.resolve([]),
-			mkdir: async () => Promise.resolve(""),
-			writeFile: async (path, content) => {
-				expect(path).toBe(expectedPath)
-				expect(content).toBe(data)
-				return Promise.resolve()
-			},
-		}
-
-		const interceptedFs = createNodeishFsWithAbsolutePaths({ basePath, nodeishFs })
-		await interceptedFs.writeFile(filePath, data)
-	})
-})

package/src/resolve-modules/createNodeishFsWithAbsolutePaths.ts

@@ -1,30 +0,0 @@
-import type { NodeishFilesystemSubset } from "@inlang/plugin"
-import { normalizePath } from "@lix-js/fs"
-
-export const createNodeishFsWithAbsolutePaths = (args: {
-	basePath: string
-	nodeishFs: NodeishFilesystemSubset
-}): NodeishFilesystemSubset => {
-	const isAbsolutePath = (path: string) => /^[/\\]/.test(path)
-
-	if (!isAbsolutePath(args.basePath)) {
-		throw new Error("The argument `settingsFilePath` of `loadProject()` must be an absolute path.")
-	}
-
-	const intercept = (path: string) => {
-		if (isAbsolutePath(path)) {
-			return path
-		}
-
-		return normalizePath(args.basePath + "/" + path)
-	}
-
-	return {
-		// @ts-expect-error
-		readFile: (path: string, options: { encoding: "utf-8" | "binary" }) =>
-			args.nodeishFs.readFile(intercept(path), options),
-		readdir: (path: string) => args.nodeishFs.readdir(intercept(path)),
-		mkdir: (path: string) => args.nodeishFs.mkdir(intercept(path)),
-		writeFile: (path: string, data: string) => args.nodeishFs.writeFile(intercept(path), data),
-	}
-}