@inlang/sdk 0.36.4 → 2.0.0-beta.2

package/dist/lint/message/lintSingleMessage.test.js

@@ -1,161 +0,0 @@
-import { beforeEach, describe, expect, test, vi } from "vitest";
-import { lintSingleMessage } from "./lintSingleMessage.js";
-import { tryCatch } from "@inlang/result";
-const lintRule1 = {
-    id: "messageLintRule.r.1",
-    displayName: "",
-    description: "",
-    run: vi.fn(),
-};
-const lintRule2 = {
-    id: "messageLintRule.r.2",
-    displayName: "",
-    description: "",
-    run: vi.fn(),
-};
-const message1 = {};
-const messages = [message1];
-describe("lintSingleMessage", async () => {
-    beforeEach(() => {
-        vi.resetAllMocks();
-    });
-    describe("resolve rules and settings", async () => {
-        // the lint function is un-opinionated and does not set a default level.
-        // opinionated users like the inlang instance can very well set a default level (separation of concerns)
-        test("it should throw if a lint level is not provided for a given lint rule", async () => {
-            lintRule1.run.mockImplementation(({ report }) => report({}));
-            const result = await tryCatch(() => lintSingleMessage({
-                settings: {
-                    sourceLanguageTag: "en",
-                    languageTags: ["en"],
-                    messageLintRuleLevels: {},
-                    modules: [],
-                },
-                messages,
-                message: message1,
-                rules: [lintRule1],
-            }));
-            expect(result.error).toBeDefined();
-            expect(result.data).toBeUndefined();
-        });
-        test("it should override the default lint level", async () => {
-            lintRule1.run.mockImplementation(({ report }) => report({}));
-            const reports = await lintSingleMessage({
-                settings: {
-                    sourceLanguageTag: "en",
-                    languageTags: ["en"],
-                    modules: [],
-                    messageLintRuleLevels: {
-                        [lintRule1.id]: "error",
-                    },
-                },
-                messages,
-                message: message1,
-                rules: [lintRule1],
-            });
-            expect(reports.data[0]?.level).toBe("error");
-        });
-        test("it should pass the correct settings", async () => {
-            const settings = {
-                sourceLanguageTag: "en",
-                languageTags: ["en"],
-                modules: [],
-                messageLintRuleLevels: {
-                    [lintRule1.id]: "warning",
-                },
-            };
-            const fn = vi.fn();
-            lintRule1.run.mockImplementation(({ settings }) => fn(settings));
-            await lintSingleMessage({
-                settings,
-                messages,
-                message: message1,
-                rules: [lintRule1],
-            });
-            expect(fn).toHaveBeenCalledWith(settings);
-        });
-    });
-    test("it should await all rules", async () => {
-        let m1Called = false;
-        let m2Called = false;
-        lintRule1.run.mockImplementation(() => {
-            m1Called = true;
-        });
-        lintRule2.run.mockImplementation(async () => {
-            await new Promise((resolve) => setTimeout(resolve, 0));
-            m2Called = true;
-        });
-        await lintSingleMessage({
-            settings: {
-                sourceLanguageTag: "en",
-                languageTags: ["en"],
-                modules: [],
-                messageLintRuleLevels: {
-                    [lintRule1.id]: "warning",
-                    [lintRule2.id]: "warning",
-                },
-            },
-            messages,
-            message: message1,
-            rules: [lintRule1, lintRule2],
-        });
-        expect(m1Called).toBe(true);
-        expect(m2Called).toBe(true);
-    });
-    test("it should process all rules in parallel", async () => {
-        const fn = vi.fn();
-        lintRule1.run.mockImplementation(async () => {
-            fn(lintRule1.id, "before");
-            await new Promise((resolve) => setTimeout(resolve, 0));
-            fn(lintRule1.id, "after");
-        });
-        lintRule2.run.mockImplementation(async () => {
-            fn(lintRule2.id, "before");
-            await new Promise((resolve) => setTimeout(resolve, 0));
-            fn(lintRule2.id, "after");
-        });
-        await lintSingleMessage({
-            settings: {
-                sourceLanguageTag: "en",
-                languageTags: ["en"],
-                modules: [],
-                messageLintRuleLevels: {
-                    [lintRule1.id]: "warning",
-                    [lintRule2.id]: "warning",
-                },
-            },
-            messages,
-            message: message1,
-            rules: [lintRule1, lintRule2],
-        });
-        expect(fn).toHaveBeenCalledTimes(4);
-        expect(fn).toHaveBeenNthCalledWith(1, lintRule1.id, "before");
-        expect(fn).toHaveBeenNthCalledWith(2, lintRule2.id, "before");
-        expect(fn).toHaveBeenNthCalledWith(3, lintRule1.id, "after");
-        expect(fn).toHaveBeenNthCalledWith(4, lintRule2.id, "after");
-    });
-    test("it should not abort the linting process when errors occur", async () => {
-        lintRule1.run.mockImplementation(() => {
-            throw new Error("error");
-        });
-        lintRule2.run.mockImplementation(({ report }) => {
-            report({});
-        });
-        const result = await lintSingleMessage({
-            settings: {
-                sourceLanguageTag: "en",
-                languageTags: ["en"],
-                modules: [],
-                messageLintRuleLevels: {
-                    [lintRule1.id]: "warning",
-                    [lintRule2.id]: "warning",
-                },
-            },
-            messages,
-            message: message1,
-            rules: [lintRule1, lintRule2],
-        });
-        expect(result.data).length(1);
-        expect(result.errors).length(1);
-    });
-});

package/dist/listProjects.d.ts

@@ -1,5 +0,0 @@
-import type { NodeishFilesystem } from "@lix-js/fs";
-export declare const listProjects: (nodeishFs: NodeishFilesystem, from: string) => Promise<Array<{
-    projectPath: string;
-}>>;
-//# sourceMappingURL=listProjects.d.ts.map

package/dist/listProjects.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"listProjects.d.ts","sourceRoot":"","sources":["../src/listProjects.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAA;AAInD,eAAO,MAAM,YAAY,cACb,iBAAiB,QACtB,MAAM,KACV,OAAO,CAAC,KAAK,CAAC;IAAE,WAAW,EAAE,MAAM,CAAA;CAAE,CAAC,CAwCxC,CAAA"}

package/dist/listProjects.js

@@ -1,38 +0,0 @@
-const ignores = ["node_modules", ".git"];
-export const listProjects = async (nodeishFs, from) => {
-    // !TODO: Remove this limit once we introduce caching
-    const recursionLimit = 5;
-    const projects = [];
-    async function searchDir(path, depth) {
-        if (depth > recursionLimit) {
-            return;
-        }
-        const files = await nodeishFs.readdir(path);
-        for (const file of files) {
-            const filePath = `${path}/${file}`;
-            try {
-                const stats = await nodeishFs.stat(filePath);
-                if (stats.isDirectory()) {
-                    if (ignores.includes(file)) {
-                        continue;
-                    }
-                    if (file.endsWith(".inlang")) {
-                        projects.push({ projectPath: filePath });
-                    }
-                    else {
-                        await searchDir(filePath, depth + 1);
-                    }
-                }
-            }
-            catch {
-                continue;
-            }
-        }
-    }
-    await searchDir(from, 0);
-    // remove double slashes
-    for (const project of projects) {
-        project.projectPath = project.projectPath.replace(/\/\//g, "/");
-    }
-    return projects;
-};

package/dist/listProjects.test.d.ts

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

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

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

package/dist/listProjects.test.js

@@ -1,72 +0,0 @@
-import { assert, describe, it, expect } from "vitest";
-import { listProjects } from "./listProjects.js";
-import { createNodeishMemoryFs } from "@lix-js/fs";
-import { mockRepo } from "@lix-js/client";
-// eslint-disable-next-line no-restricted-imports -- test
-import { readFileSync } from "node:fs";
-const settings = {
-    sourceLanguageTag: "en",
-    languageTags: ["en"],
-    modules: ["plugin.js", "lintRule.js"],
-    messageLintRuleLevels: {
-        "messageLintRule.project.missingTranslation": "error",
-    },
-    "plugin.project.i18next": {
-        pathPattern: "./examples/example01/{languageTag}.json",
-        variableReferencePattern: ["{", "}"],
-    },
-};
-describe("listProjects", () => {
-    it("should find all projects a given path", async () => {
-        const fs = createNodeishMemoryFs();
-        await fs.mkdir("/user/dir1/project.inlang", { recursive: true });
-        await fs.writeFile("/user/dir1/project.inlang/settings.json", JSON.stringify(settings));
-        await fs.mkdir("/user/dir2/project.inlang", { recursive: true });
-        await fs.writeFile("/user/dir2/project.inlang/settings.json", JSON.stringify(settings));
-        await listProjects(fs, "/user").then((projects) => {
-            assert(projects.length === 2);
-        });
-    });
-    it("should return objects inside of an array with the projectPath", async () => {
-        const fs = createNodeishMemoryFs();
-        await fs.mkdir("/user/dir1/project.inlang", { recursive: true });
-        await fs.writeFile("/user/dir1/project.inlang/settings.json", JSON.stringify(settings));
-        await fs.mkdir("/user/dir2/project.inlang", { recursive: true });
-        await fs.writeFile("/user/dir2/project.inlang/settings.json", JSON.stringify(settings));
-        await listProjects(fs, "/user").then((projects) => {
-            assert.isTrue(typeof projects[0] === "object");
-            assert.isTrue(typeof projects[0]?.projectPath === "string");
-        });
-    });
-    it("should limit the recursion depth to 5", async () => {
-        const fs = createNodeishMemoryFs();
-        await fs.mkdir("/user/dir1/dir2/dir3/dir4/dir5/dir6/project.inlang", { recursive: true });
-        await fs.writeFile("/user/dir1/dir2/dir3/dir4/dir5/dir6/project.inlang/settings.json", JSON.stringify(settings));
-        await listProjects(fs, "/user").then((projects) => {
-            assert(projects.length === 0);
-        });
-    });
-    it("should not crash on broken symlinks as cal.com has", async () => {
-        const ciTestRepo = JSON.parse(readFileSync("./mocks/ci-test-repo-no-shallow.json", { encoding: "utf-8" }));
-        const repo = await mockRepo({
-            fromSnapshot: ciTestRepo,
-            repoOptions: { experimentalFeatures: { lixCommit: true, lazyClone: false } },
-        });
-        repo.checkout({ branch: "test-symlink" });
-        const link = await repo.nodeishFs.readlink("test-symlink-not-existing-target");
-        expect(link).toBe("/test-symlink-not-existing-target//.././no-exist");
-        await listProjects(repo.nodeishFs, "/").then((projects) => {
-            assert(projects.length === 1);
-        });
-    });
-    it("should also find files inside of a dir that ends with *.inlang", async () => {
-        const fs = createNodeishMemoryFs();
-        await fs.mkdir("/user/dir1/go.inlang", { recursive: true });
-        await fs.writeFile("/user/dir1/go.inlang/settings.json", JSON.stringify(settings));
-        await fs.mkdir("/user/dir2/flutter.inlang", { recursive: true });
-        await fs.writeFile("/user/dir2/flutter.inlang/settings.json", JSON.stringify(settings));
-        await listProjects(fs, "/user").then((projects) => {
-            assert(projects.length === 2);
-        });
-    });
-});

package/dist/loadProject.d.ts

@@ -1,19 +0,0 @@
-import type { InlangProject, Subscribable } from "./api.js";
-import { type ImportFunction } from "./resolve-modules/index.js";
-import type { Repository } from "@lix-js/client";
-/**
- * @param projectPath - Absolute path to the inlang settings file.
- * @param repo - An instance of a lix repo as returned by `openRepository`.
- * @param _import - Use `_import` to pass a custom import function for testing,
- *   and supporting legacy resolvedModules such as CJS.
- * @param appId - The app id to use for telemetry e.g "app.inlang.badge"
- *
- */
-export declare function loadProject(args: {
-    projectPath: string;
-    repo: Repository;
-    appId?: string;
-    _import?: ImportFunction;
-}): Promise<InlangProject>;
-export declare function createSubscribable<T>(signal: () => T): Subscribable<T>;
-//# sourceMappingURL=loadProject.d.ts.map

package/dist/loadProject.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"loadProject.d.ts","sourceRoot":"","sources":["../src/loadProject.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACX,aAAa,EAGb,YAAY,EAGZ,MAAM,UAAU,CAAA;AACjB,OAAO,EAAE,KAAK,cAAc,EAAkB,MAAM,4BAA4B,CAAA;AAuBhF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAchD;;;;;;;GAOG;AACH,wBAAsB,WAAW,CAAC,IAAI,EAAE;IACvC,WAAW,EAAE,MAAM,CAAA;IACnB,IAAI,EAAE,UAAU,CAAA;IAChB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,OAAO,CAAC,EAAE,cAAc,CAAA;CACxB,GAAG,OAAO,CAAC,aAAa,CAAC,CAoSzB;AAoGD,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,CAQtE"}

package/dist/loadProject.js

@@ -1,343 +0,0 @@
-import { resolveModules } from "./resolve-modules/index.js";
-import { TypeCompiler, ValueErrorType } from "@sinclair/typebox/compiler";
-import { ProjectSettingsFileJSONSyntaxError, ProjectSettingsFileNotFoundError, ProjectSettingsInvalidError, } from "./errors.js";
-import { createRoot, createSignal, createEffect, batch } from "./reactivity/solid.js";
-import { createMessagesQuery } from "./createMessagesQuery.js";
-import { createMessageLintReportsQuery } from "./createMessageLintReportsQuery.js";
-import { ProjectSettings } from "./versionedInterfaces.js";
-import { tryCatch } from "@inlang/result";
-import { migrateIfOutdated } from "@inlang/project-settings/migration";
-import { createNodeishFsWithAbsolutePaths } from "./createNodeishFsWithAbsolutePaths.js";
-import { createNodeishFsWithWatcher } from "./createNodeishFsWithWatcher.js";
-import { normalizePath } from "@lix-js/fs";
-import { assertValidProjectPath } from "./validateProjectPath.js";
-// Migrations
-import { maybeMigrateToDirectory } from "./migrations/migrateToDirectory.js";
-import { maybeCreateFirstProjectId } from "./migrations/maybeCreateFirstProjectId.js";
-import { maybeAddModuleCache } from "./migrations/maybeAddModuleCache.js";
-import { capture } from "./telemetry/capture.js";
-import { identifyProject } from "./telemetry/groupIdentify.js";
-import { stubMessagesQuery, stubMessageLintReportsQuery } from "./v2/stubQueryApi.js";
-import { openStore } from "./persistence/store.js";
-import _debug from "debug";
-const debug = _debug("sdk:loadProject");
-const settingsCompiler = TypeCompiler.Compile(ProjectSettings);
-/**
- * @param projectPath - Absolute path to the inlang settings file.
- * @param repo - An instance of a lix repo as returned by `openRepository`.
- * @param _import - Use `_import` to pass a custom import function for testing,
- *   and supporting legacy resolvedModules such as CJS.
- * @param appId - The app id to use for telemetry e.g "app.inlang.badge"
- *
- */
-export async function loadProject(args) {
-    const projectPath = normalizePath(args.projectPath);
-    // -- 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.
-    assertValidProjectPath(projectPath);
-    debug(projectPath);
-    const nodeishFs = createNodeishFsWithAbsolutePaths({
-        projectPath,
-        nodeishFs: args.repo.nodeishFs,
-    });
-    // -- migratations ------------------------------------------------
-    await maybeMigrateToDirectory({ nodeishFs, projectPath });
-    await maybeCreateFirstProjectId({ projectPath, repo: args.repo });
-    await maybeAddModuleCache({ projectPath, repo: args.repo });
-    // -- load project ------------------------------------------------------
-    return await createRoot(async () => {
-        // TODO remove tryCatch after https://github.com/opral/monorepo/issues/2013
-        // - a repo will always be present
-        // - if a repo is present, the project id will always be present
-        const { data: projectId } = await tryCatch(() => nodeishFs.readFile(args.projectPath + "/project_id", { encoding: "utf-8" }));
-        const [initialized, markInitAsComplete, markInitAsFailed] = createAwaitable();
-        const [loadedSettings, markSettingsAsLoaded, markSettingsAsFailed] = createAwaitable();
-        const [resolvedModules, setResolvedModules] = createSignal();
-        // -- settings ------------------------------------------------------------
-        const [settings, _setSettings] = createSignal();
-        let v2Persistence = false;
-        let locales = [];
-        // TODO:
-        // if (projectId) {
-        // 	telemetryBrowser.group("project", projectId, {
-        // 		name: projectId,
-        // 	})
-        // }
-        const setSettings = (newSettings) => {
-            try {
-                const validatedSettings = parseSettings(newSettings);
-                v2Persistence = !!validatedSettings.experimental?.persistence;
-                locales = validatedSettings.languageTags;
-                batch(() => {
-                    // reset the resolved modules first - since they are no longer valid at that point
-                    setResolvedModules(undefined);
-                    _setSettings(validatedSettings);
-                });
-                return { data: validatedSettings };
-            }
-            catch (error) {
-                if (error instanceof ProjectSettingsInvalidError) {
-                    return { error };
-                }
-                throw new Error("Unhandled error in setSettings. This is an internal bug. Please file an issue.", { cause: error });
-            }
-        };
-        const nodeishFsWithWatchersForSettings = createNodeishFsWithWatcher({
-            nodeishFs: nodeishFs,
-            onChange: async () => {
-                const readSettingsResult = await tryCatch(async () => await loadSettings({
-                    settingsFilePath: projectPath + "/settings.json",
-                    nodeishFs: nodeishFs,
-                }));
-                if (readSettingsResult.error)
-                    return;
-                const newSettings = readSettingsResult.data;
-                if (JSON.stringify(newSettings) !== JSON.stringify(settings())) {
-                    setSettings(newSettings);
-                }
-            },
-        });
-        const settingsResult = await tryCatch(async () => await loadSettings({
-            settingsFilePath: projectPath + "/settings.json",
-            nodeishFs: nodeishFsWithWatchersForSettings,
-        }));
-        if (settingsResult.error) {
-            markInitAsFailed(settingsResult.error);
-            markSettingsAsFailed(settingsResult.error);
-        }
-        else {
-            setSettings(settingsResult.data);
-            markSettingsAsLoaded();
-        }
-        // -- resolvedModules -----------------------------------------------------------
-        createEffect(() => {
-            const _settings = settings();
-            if (!_settings)
-                return;
-            resolveModules({
-                settings: _settings,
-                nodeishFs,
-                _import: args._import,
-                projectPath,
-            })
-                .then((resolvedModules) => {
-                setResolvedModules(resolvedModules);
-            })
-                .catch((err) => markInitAsFailed(err));
-        });
-        // -- installed items ----------------------------------------------------
-        let settingsValue;
-        // workaround to not run effects twice (e.g. settings change + modules change) (I'm sure there exists a solid way of doing this, but I haven't found it yet)
-        createEffect(() => (settingsValue = settings()));
-        const installedMessageLintRules = () => {
-            if (!resolvedModules())
-                return [];
-            return resolvedModules().messageLintRules.map((rule) => ({
-                id: rule.id,
-                displayName: rule.displayName,
-                description: rule.description,
-                module: resolvedModules()?.meta.find((m) => m.id.includes(rule.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/opral/monorepo/issues/1254
-                level: settingsValue["messageLintRuleLevels"]?.[rule.id] ?? "warning",
-                settingsSchema: rule.settingsSchema,
-            }));
-        };
-        const installedPlugins = () => {
-            if (!resolvedModules())
-                return [];
-            return resolvedModules().plugins.map((plugin) => ({
-                id: plugin.id,
-                displayName: plugin.displayName,
-                description: plugin.description,
-                module: resolvedModules()?.meta.find((m) => m.id.includes(plugin.id))?.module ??
-                    "Unknown module. You stumbled on a bug in inlang's source code. Please open an issue.",
-                settingsSchema: plugin.settingsSchema,
-            }));
-        };
-        // -- messages ----------------------------------------------------------
-        const [loadMessagesViaPluginError, setLoadMessagesViaPluginError] = createSignal();
-        const [saveMessagesViaPluginError, setSaveMessagesViaPluginError] = createSignal();
-        let messagesQuery;
-        let lintReportsQuery;
-        let store;
-        // wait for seetings to load v2Persistence flag
-        // .catch avoids throwing here if the awaitable is rejected
-        // error is recorded via markInitAsFailed so no need to capture it again
-        await loadedSettings.catch(() => { });
-        if (v2Persistence) {
-            messagesQuery = stubMessagesQuery;
-            lintReportsQuery = stubMessageLintReportsQuery;
-            try {
-                store = await openStore({ projectPath, nodeishFs, locales });
-                markInitAsComplete();
-            }
-            catch (e) {
-                markInitAsFailed(e);
-            }
-        }
-        else {
-            messagesQuery = createMessagesQuery({
-                projectPath,
-                nodeishFs,
-                settings,
-                resolvedModules,
-                onInitialMessageLoadResult: (e) => {
-                    if (e) {
-                        markInitAsFailed(e);
-                    }
-                    else {
-                        markInitAsComplete();
-                    }
-                },
-                onLoadMessageResult: (e) => {
-                    setLoadMessagesViaPluginError(e);
-                },
-                onSaveMessageResult: (e) => {
-                    setSaveMessagesViaPluginError(e);
-                },
-            });
-            lintReportsQuery = createMessageLintReportsQuery(messagesQuery, settings, installedMessageLintRules, resolvedModules);
-            store = undefined;
-        }
-        // -- app ---------------------------------------------------------------
-        const initializeError = await initialized.catch((error) => error);
-        /**
-         * Utility to escape reactive tracking and avoid multiple calls to
-         * the capture event.
-         *
-         * Should be addressed with https://github.com/opral/monorepo/issues/1772
-         */
-        let projectLoadedCapturedAlready = false;
-        if (projectId && projectLoadedCapturedAlready === false) {
-            projectLoadedCapturedAlready = true;
-            // TODO ensure that capture is "awaited" without blocking the the app from starting
-            await identifyProject({
-                projectId,
-                properties: {
-                    // using the id for now as a name but can be changed in the future
-                    // we need at least one property to make a project visible in the dashboard
-                    name: projectId,
-                },
-            });
-            await capture("SDK loaded project", {
-                projectId,
-                properties: {
-                    appId: args.appId,
-                    settings: settings(),
-                    installedPluginIds: installedPlugins().map((p) => p.id),
-                    installedMessageLintRuleIds: installedMessageLintRules().map((r) => r.id),
-                    // TODO: fix for v2Persistence
-                    // https://github.com/opral/inlang-message-sdk/issues/78
-                    numberOfMessages: messagesQuery.includedMessageIds().length,
-                },
-            });
-        }
-        return {
-            id: projectId,
-            installed: {
-                plugins: createSubscribable(() => installedPlugins()),
-                messageLintRules: createSubscribable(() => installedMessageLintRules()),
-            },
-            errors: createSubscribable(() => [
-                ...(initializeError ? [initializeError] : []),
-                ...(resolvedModules() ? resolvedModules().errors : []),
-                ...(loadMessagesViaPluginError() ? [loadMessagesViaPluginError()] : []),
-                ...(saveMessagesViaPluginError() ? [saveMessagesViaPluginError()] : []),
-                // have a query error exposed
-                //...(lintErrors() ?? []),
-            ]),
-            settings: createSubscribable(() => settings()),
-            setSettings: (newSettings) => {
-                const result = setSettings(newSettings);
-                if (!result.error)
-                    writeSettingsToDisk({ nodeishFs, settings: result.data, projectPath });
-                return result.error ? result : { data: undefined };
-            },
-            customApi: createSubscribable(() => resolvedModules()?.resolvedPluginApi.customApi || {}),
-            query: {
-                messages: messagesQuery,
-                messageLintReports: lintReportsQuery,
-            },
-            store,
-        };
-    });
-}
-// ------------------------------------------------------------------------------------------------
-const loadSettings = async (args) => {
-    const { data: settingsFile, error: settingsFileError } = await tryCatch(async () => await args.nodeishFs.readFile(args.settingsFilePath, { encoding: "utf-8" }));
-    if (settingsFileError)
-        throw new ProjectSettingsFileNotFoundError({
-            cause: settingsFileError,
-            path: args.settingsFilePath,
-        });
-    const json = tryCatch(() => JSON.parse(settingsFile));
-    if (json.error) {
-        throw new ProjectSettingsFileJSONSyntaxError({
-            cause: json.error,
-            path: args.settingsFilePath,
-        });
-    }
-    return parseSettings(json.data);
-};
-/**
- * @throws If the settings are not valid
- */
-const parseSettings = (settings) => {
-    const withMigration = migrateIfOutdated(settings);
-    if (settingsCompiler.Check(withMigration) === false) {
-        const typeErrors = [...settingsCompiler.Errors(settings)];
-        if (typeErrors.length > 0) {
-            throw new ProjectSettingsInvalidError({
-                errors: typeErrors,
-            });
-        }
-    }
-    const { sourceLanguageTag, languageTags } = settings;
-    if (!languageTags.includes(sourceLanguageTag)) {
-        throw new ProjectSettingsInvalidError({
-            errors: [
-                {
-                    message: `The sourceLanguageTag "${sourceLanguageTag}" is not included in the languageTags "${languageTags.join('", "')}". Please add it to the languageTags.`,
-                    type: ValueErrorType.String,
-                    schema: ProjectSettings,
-                    value: sourceLanguageTag,
-                    path: "sourceLanguageTag",
-                },
-            ],
-        });
-    }
-    return withMigration;
-};
-const writeSettingsToDisk = async (args) => {
-    const serializeResult = tryCatch(() => 
-    // TODO: this will probably not match the original formatting
-    JSON.stringify(args.settings, undefined, 2));
-    if (serializeResult.error)
-        throw serializeResult.error;
-    const serializedSettings = serializeResult.data;
-    const writeResult = await tryCatch(async () => await args.nodeishFs.writeFile(args.projectPath + "/settings.json", serializedSettings));
-    if (writeResult.error)
-        throw writeResult.error;
-};
-// ------------------------------------------------------------------------------------------------
-const createAwaitable = () => {
-    let resolve;
-    let reject;
-    const promise = new Promise((res, rej) => {
-        resolve = res;
-        reject = rej;
-    });
-    return [promise, resolve, reject];
-};
-export function createSubscribable(signal) {
-    return Object.assign(signal, {
-        subscribe: (callback) => {
-            createEffect(() => {
-                callback(signal());
-            });
-        },
-    });
-}

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

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