@inlang/sdk 0.36.4 → 2.0.0-beta.1

package/dist/messages/variant.test.js

@@ -1,439 +0,0 @@
-/* eslint-disable @typescript-eslint/no-non-null-assertion */
-import { createVariant, getVariant, updateVariantPattern } from "./variant.js";
-import { describe, test, expect } from "vitest";
-import { MessagePatternsForLanguageTagDoNotExistError, MessageVariantAlreadyExistsError, MessageVariantDoesNotExistError, } from "./errors.js";
-describe("getVariant", () => {
-    test("should return the correct variant of a message", () => {
-        const mockMessage = getMockMessage();
-        const variant = getVariant(mockMessage, {
-            where: {
-                languageTag: "en",
-                match: ["female", "1"],
-            },
-        });
-        expect(variant?.pattern[0]).toStrictEqual({
-            type: "Text",
-            value: "{$hostName} invites {$guestName} to her party.",
-        });
-    });
-    test("should return the correct fallback because the exact match does not exist", () => {
-        const mockMessage = getMockMessage();
-        const variant = getVariant(mockMessage, {
-            where: {
-                languageTag: "en",
-                match: ["female", "0"],
-            },
-        });
-        expect(variant?.pattern[0]).toStrictEqual({
-            type: "Text",
-            value: "{$hostName} invites {$guestName} and {$guestsOther} other people to her party.",
-        });
-    });
-    test("it should not throw error if selector is empty and match", () => {
-        const mockMessage = {
-            id: "mockMessage",
-            alias: {},
-            selectors: [],
-            variants: [
-                {
-                    languageTag: "en",
-                    pattern: [{ type: "Text", value: "Gender male" }],
-                    match: [],
-                },
-                {
-                    languageTag: "de",
-                    pattern: [{ type: "Text", value: "Veraltete Übersetzung" }],
-                    match: [],
-                },
-            ],
-        };
-        const variant = getVariant(mockMessage, {
-            where: {
-                languageTag: "en",
-                match: [],
-            },
-        });
-        expect(variant).toBeDefined();
-    });
-    test("it should not throw error if selector is empty, return undefined", () => {
-        const mockMessage = {
-            id: "mockMessage",
-            alias: {},
-            selectors: [],
-            variants: [
-                {
-                    languageTag: "en",
-                    pattern: [{ type: "Text", value: "Gender male" }],
-                    match: ["male", "*"],
-                },
-                {
-                    languageTag: "de",
-                    pattern: [{ type: "Text", value: "Veraltete Übersetzung" }],
-                    match: ["*", "*"],
-                },
-            ],
-        };
-        const variant = getVariant(mockMessage, {
-            where: {
-                languageTag: "fr",
-                match: ["*", "*"],
-            },
-        });
-        expect(variant).toBeUndefined();
-    });
-    test("the matcher should resolve not existing selectors to '*'", () => {
-        const mockMessage = getMockMessage();
-        const variant = getVariant(mockMessage, {
-            where: {
-                languageTag: "en",
-                match: ["*", "0"],
-            },
-        });
-        expect(variant?.pattern[0]).toStrictEqual({
-            type: "Text",
-            value: "{$hostName} does not give a party.",
-        });
-    });
-    test("empty selector should result in '*','*'", () => {
-        const mockMessage = getMockMessage();
-        const variant = getVariant(mockMessage, {
-            where: {
-                languageTag: "en",
-                match: ["*", "*"],
-            },
-        });
-        expect(variant?.pattern[0]).toStrictEqual({
-            type: "Text",
-            value: "{$hostName} invites {$guestName} and {$guestsOther} other people to their party.",
-        });
-    });
-    test("non existing selector values should be resolved", () => {
-        const mockMessage = getMockMessage();
-        const variant = getVariant(mockMessage, {
-            where: {
-                languageTag: "en",
-                match: ["trans", "2"],
-            },
-        });
-        expect(variant?.pattern[0]).toStrictEqual({
-            type: "Text",
-            value: "{$hostName} invites {$guestName} and one other person to their party.",
-        });
-        const variant2 = getVariant(mockMessage, {
-            where: {
-                languageTag: "en",
-                match: ["male", "8"],
-            },
-        });
-        expect(variant2?.pattern[0]).toStrictEqual({
-            type: "Text",
-            value: "{$hostName} invites {$guestName} and {$guestsOther} other people to his party.",
-        });
-    });
-    test("should return undefined of no variant matches", () => {
-        const mockMessage = getMockMessage();
-        mockMessage.variants = [
-            ...mockMessage.variants.filter((v) => v.languageTag === "en" && (v.match[0] !== "*" || v.match[1] !== "*")),
-        ];
-        const variant = getVariant(mockMessage, {
-            where: {
-                languageTag: "en",
-                match: ["*", "*"],
-            },
-        });
-        expect(variant).toBeUndefined();
-    });
-    test("should return undefined if a variant for specific language does not exist", () => {
-        const mockMessage = getMockMessage();
-        const variant = getVariant(mockMessage, {
-            where: {
-                languageTag: "de",
-                match: ["female", "1"],
-            },
-        });
-        expect(variant).toBeUndefined();
-    });
-    test("should return undefined variant if no selector defined", () => {
-        const mockMessage = {};
-        mockMessage.selectors = [];
-        mockMessage.variants = [
-            {
-                languageTag: "en",
-                match: ["*", "*"],
-                pattern: [
-                    {
-                        type: "Text",
-                        value: "test",
-                    },
-                ],
-            },
-        ];
-        const variant = getVariant(mockMessage, {
-            where: {
-                languageTag: "en",
-                match: ["*", "*"],
-            },
-        });
-        // should return undefined
-        expect(variant).toBeUndefined();
-    });
-    test("should match catch all if the number of matches and selectors do not match", () => {
-        const mockMessage = getMockMessage();
-        const variant1 = getVariant(mockMessage, {
-            where: {
-                languageTag: "en",
-                match: ["12"],
-            },
-        });
-        // should return catch all
-        expect(variant1?.pattern[0]).toStrictEqual({
-            type: "Text",
-            value: "{$hostName} invites {$guestName} and {$guestsOther} other people to their party.",
-        });
-        const variant2 = getVariant(mockMessage, {
-            where: {
-                languageTag: "en",
-                match: ["12", "*", "23"],
-            },
-        });
-        // should return catch all
-        expect(variant2?.pattern[0]).toStrictEqual({
-            type: "Text",
-            value: "{$hostName} invites {$guestName} and {$guestsOther} other people to their party.",
-        });
-        const variant3 = getVariant(mockMessage, {
-            where: {
-                languageTag: "en",
-                match: [],
-            },
-        });
-        // should return catch all
-        expect(variant3?.pattern[0]).toStrictEqual({
-            type: "Text",
-            value: "{$hostName} invites {$guestName} and {$guestsOther} other people to their party.",
-        });
-    });
-});
-describe("createVariant", () => {
-    test("should create a variant for a message", () => {
-        const mockMessage = getMockMessage();
-        const newVariant = {
-            languageTag: "en",
-            match: ["female", "0"],
-            pattern: [],
-        };
-        const message = createVariant(mockMessage, {
-            data: newVariant,
-        });
-        // should return the female variant
-        expect(message.data.variants.find((v) => v.languageTag === "en" && v.match[0] === "female" && v.match[1] === "0")?.pattern).toStrictEqual([]);
-    });
-    test("should create a variant, also if matcher are not full defined", () => {
-        const mockMessage = getMockMessage();
-        mockMessage.variants = [
-            ...mockMessage.variants.filter((v) => v.languageTag === "en" && (v.match[0] !== "*" || v.match[1] !== "*")),
-        ];
-        const message = createVariant(mockMessage, {
-            data: {
-                languageTag: "en",
-                match: ["*", "*"],
-                pattern: [],
-            },
-        });
-        // should return the female variant
-        expect(message.data.variants.find((v) => v.languageTag === "en" && v.match[0] === "*" && v.match[1] === "*")?.pattern).toStrictEqual([]);
-    });
-    test("should return error if variant matches", () => {
-        const mockMessage = getMockMessage();
-        const variant = createVariant(mockMessage, {
-            data: {
-                languageTag: "en",
-                match: ["male", "1"],
-                pattern: [],
-            },
-        });
-        // should return the female variant
-        expect(variant.data).toBeUndefined();
-        expect(variant.error).toBeInstanceOf(MessageVariantAlreadyExistsError);
-    });
-    test("should not return error if set of variants for specific language does not exist", () => {
-        const mockMessage = getMockMessage();
-        const variant = createVariant(mockMessage, {
-            data: {
-                languageTag: "de",
-                match: ["female", "1"],
-                pattern: [],
-            },
-        });
-        // should return the female variant
-        expect(variant.data).toBeDefined();
-        expect(variant.error).toBeUndefined();
-    });
-});
-describe("updateVariant", () => {
-    test("should update a variant of a message", () => {
-        const mockMessage = getMockMessage();
-        const message = updateVariantPattern(mockMessage, {
-            where: {
-                languageTag: "en",
-                match: ["female", "1"],
-            },
-            data: [],
-        });
-        // should return the female variant
-        expect(message.data.variants.find((v) => v.languageTag === "en" && v.match[0] === "female" && v.match[1] === "1")?.pattern).toStrictEqual([]);
-    });
-    test("should update a variant, also if matcher are not full defined", () => {
-        const mockMessage = getMockMessage();
-        const message = updateVariantPattern(mockMessage, {
-            where: {
-                languageTag: "en",
-                match: ["*", "*"],
-            },
-            data: [],
-        });
-        // should return the female variant
-        expect(message.data.variants.find((v) => v.languageTag === "en" && v.match[0] === "*" && v.match[1] === "*")?.pattern).toStrictEqual([]);
-    });
-    test("should return error if no variant matches", () => {
-        const mockMessage = getMockMessage();
-        mockMessage.variants = [
-            ...mockMessage.variants.filter((v) => v.languageTag === "en" && (v.match[0] !== "*" || v.match[1] !== "*")),
-        ];
-        const variant = updateVariantPattern(mockMessage, {
-            where: {
-                languageTag: "en",
-                match: ["*", "*"],
-            },
-            data: [],
-        });
-        // should return the female variant
-        expect(variant.data).toBeUndefined();
-        expect(variant.error).toBeInstanceOf(MessageVariantDoesNotExistError);
-    });
-    test("should return error if set of variants for specific language does not exist", () => {
-        const mockMessage = getMockMessage();
-        const variant = updateVariantPattern(mockMessage, {
-            where: {
-                languageTag: "de",
-                match: ["*", "*"],
-            },
-            data: [],
-        });
-        // should return the female variant
-        expect(variant.data).toBeUndefined();
-        expect(variant.error).toBeInstanceOf(MessagePatternsForLanguageTagDoNotExistError);
-    });
-});
-const getMockMessage = () => {
-    return {
-        id: "first-message",
-        alias: {},
-        selectors: [
-            { type: "VariableReference", name: "gender" },
-            { type: "VariableReference", name: "guestOther" },
-        ],
-        variants: [
-            {
-                languageTag: "en",
-                match: ["female", "1"],
-                pattern: [
-                    {
-                        type: "Text",
-                        value: "{$hostName} invites {$guestName} to her party.",
-                    },
-                ],
-            },
-            {
-                languageTag: "en",
-                match: ["female", "2"],
-                pattern: [
-                    {
-                        type: "Text",
-                        value: "{$hostName} invites {$guestName} and one other person to her party.",
-                    },
-                ],
-            },
-            {
-                languageTag: "en",
-                match: ["female", "*"],
-                pattern: [
-                    {
-                        type: "Text",
-                        value: "{$hostName} invites {$guestName} and {$guestsOther} other people to her party.",
-                    },
-                ],
-            },
-            {
-                languageTag: "en",
-                match: ["male", "1"],
-                pattern: [
-                    {
-                        type: "Text",
-                        value: "{$hostName} invites {$guestName} to his party.",
-                    },
-                ],
-            },
-            {
-                languageTag: "en",
-                match: ["male", "2"],
-                pattern: [
-                    {
-                        type: "Text",
-                        value: "{$hostName} invites {$guestName} and one other person to his party.",
-                    },
-                ],
-            },
-            {
-                languageTag: "en",
-                match: ["male", "*"],
-                pattern: [
-                    {
-                        type: "Text",
-                        value: "{$hostName} invites {$guestName} and {$guestsOther} other people to his party.",
-                    },
-                ],
-            },
-            {
-                languageTag: "en",
-                match: ["*", "0"],
-                pattern: [
-                    {
-                        type: "Text",
-                        value: "{$hostName} does not give a party.",
-                    },
-                ],
-            },
-            {
-                languageTag: "en",
-                match: ["*", "1"],
-                pattern: [
-                    {
-                        type: "Text",
-                        value: "{$hostName} invites {$guestName} to their party.",
-                    },
-                ],
-            },
-            {
-                languageTag: "en",
-                match: ["*", "2"],
-                pattern: [
-                    {
-                        type: "Text",
-                        value: "{$hostName} invites {$guestName} and one other person to their party.",
-                    },
-                ],
-            },
-            {
-                languageTag: "en",
-                match: ["*", "*"],
-                pattern: [
-                    {
-                        type: "Text",
-                        value: "{$hostName} invites {$guestName} and {$guestsOther} other people to their party.",
-                    },
-                ],
-            },
-        ],
-    };
-};

package/dist/migrations/maybeAddModuleCache.d.ts

@@ -1,6 +0,0 @@
-import type { Repository } from "@lix-js/client";
-export declare function maybeAddModuleCache(args: {
-    projectPath: string;
-    repo?: Repository;
-}): Promise<void>;
-//# sourceMappingURL=maybeAddModuleCache.d.ts.map

package/dist/migrations/maybeAddModuleCache.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"maybeAddModuleCache.d.ts","sourceRoot":"","sources":["../../src/migrations/maybeAddModuleCache.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAKhD,wBAAsB,mBAAmB,CAAC,IAAI,EAAE;IAC/C,WAAW,EAAE,MAAM,CAAA;IACnB,IAAI,CAAC,EAAE,UAAU,CAAA;CACjB,GAAG,OAAO,CAAC,IAAI,CAAC,CAyChB"}

package/dist/migrations/maybeAddModuleCache.js

@@ -1,62 +0,0 @@
-const EXPECTED_IGNORES = ["cache"];
-export async function maybeAddModuleCache(args) {
-    if (args.repo === undefined)
-        return;
-    const projectExists = await directoryExists(args.projectPath, args.repo.nodeishFs);
-    if (!projectExists)
-        return;
-    const gitignorePath = args.projectPath + "/.gitignore";
-    const moduleCache = args.projectPath + "/cache/modules/";
-    const gitignoreExists = await fileExists(gitignorePath, args.repo.nodeishFs);
-    const moduleCacheExists = await directoryExists(moduleCache, args.repo.nodeishFs);
-    if (gitignoreExists) {
-        // non-destructively add any missing ignores
-        try {
-            const gitignore = await args.repo.nodeishFs.readFile(gitignorePath, { encoding: "utf-8" });
-            const missingIgnores = EXPECTED_IGNORES.filter((ignore) => !gitignore.includes(ignore));
-            if (missingIgnores.length > 0) {
-                await args.repo.nodeishFs.appendFile(gitignorePath, "\n" + missingIgnores.join("\n"));
-            }
-        }
-        catch (error) {
-            throw new Error("[migrate:module-cache] Failed to update .gitignore", { cause: error });
-        }
-    }
-    else {
-        try {
-            await args.repo.nodeishFs.writeFile(gitignorePath, EXPECTED_IGNORES.join("\n"));
-        }
-        catch (e) {
-            // @ts-ignore
-            if (e.code && e.code !== "EISDIR" && e.code !== "EEXIST") {
-                throw new Error("[migrate:module-cache] Failed to create .gitignore", { cause: e });
-            }
-        }
-    }
-    if (!moduleCacheExists) {
-        try {
-            await args.repo.nodeishFs.mkdir(moduleCache, { recursive: true });
-        }
-        catch (e) {
-            throw new Error("[migrate:module-cache] Failed to create cache directory", { cause: e });
-        }
-    }
-}
-async function fileExists(path, nodeishFs) {
-    try {
-        const stat = await nodeishFs.stat(path);
-        return stat.isFile();
-    }
-    catch {
-        return false;
-    }
-}
-async function directoryExists(path, nodeishFs) {
-    try {
-        const stat = await nodeishFs.stat(path);
-        return stat.isDirectory();
-    }
-    catch {
-        return false;
-    }
-}

package/dist/migrations/maybeCreateFirstProjectId.d.ts

@@ -1,16 +0,0 @@
-import type { Repository } from "@lix-js/client";
-/**
- * Creates a project id if it does not exist yet.
- *
- * - this is a migration to ensure that all projects have a project id
- * - new projects are created with a project id (in the future)
- */
-export declare function maybeCreateFirstProjectId(args: {
-    projectPath: string;
-    repo?: Repository;
-}): Promise<void>;
-export declare function generateProjectId(args: {
-    repo?: Repository;
-    projectPath: string;
-}): Promise<string | undefined>;
-//# sourceMappingURL=maybeCreateFirstProjectId.d.ts.map

package/dist/migrations/maybeCreateFirstProjectId.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"maybeCreateFirstProjectId.d.ts","sourceRoot":"","sources":["../../src/migrations/maybeCreateFirstProjectId.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAGhD;;;;;GAKG;AACH,wBAAsB,yBAAyB,CAAC,IAAI,EAAE;IACrD,WAAW,EAAE,MAAM,CAAA;IACnB,IAAI,CAAC,EAAE,UAAU,CAAA;CACjB,GAAG,OAAO,CAAC,IAAI,CAAC,CAsBhB;AAED,wBAAsB,iBAAiB,CAAC,IAAI,EAAE;IAAE,IAAI,CAAC,EAAE,UAAU,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAE,+BAcvF"}

package/dist/migrations/maybeCreateFirstProjectId.js

@@ -1,46 +0,0 @@
-import { hash } from "@lix-js/client";
-/**
- * Creates a project id if it does not exist yet.
- *
- * - this is a migration to ensure that all projects have a project id
- * - new projects are created with a project id (in the future)
- */
-export async function maybeCreateFirstProjectId(args) {
-    // the migration assumes a repository
-    if (args.repo === undefined) {
-        return;
-    }
-    try {
-        await args.repo.nodeishFs.readFile(args.projectPath + "/project_id", {
-            encoding: "utf-8",
-        });
-    }
-    catch (error) {
-        // @ts-ignore
-        if (error.code === "ENOENT" && args.repo) {
-            const projectId = await generateProjectId({ repo: args.repo, projectPath: args.projectPath });
-            if (projectId) {
-                await args.repo.nodeishFs
-                    .writeFile(args.projectPath + "/project_id", projectId)
-                    .catch((error) => {
-                    console.error("Failed to write project_id", error);
-                });
-            }
-        }
-    }
-}
-export async function generateProjectId(args) {
-    if (!args.repo || !args.projectPath) {
-        return undefined;
-    }
-    const firstCommitHash = await args.repo.getFirstCommitHash();
-    if (firstCommitHash) {
-        try {
-            return await hash(`${firstCommitHash + args.projectPath}`);
-        }
-        catch (error) {
-            console.error("Failed to generate project_id", error);
-        }
-    }
-    return undefined;
-}

package/dist/migrations/maybeCreateFirstProjectId.test.d.ts

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

package/dist/migrations/maybeCreateFirstProjectId.test.d.ts.map

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

package/dist/migrations/maybeCreateFirstProjectId.test.js

@@ -1,24 +0,0 @@
-import { generateProjectId } from "./maybeCreateFirstProjectId.js";
-import { it, expect } from "vitest";
-import { mockRepo } from "@lix-js/client";
-import {} from "@lix-js/fs";
-// eslint-disable-next-line no-restricted-imports -- test
-import { readFileSync } from "node:fs";
-const ciTestRepo = JSON.parse(readFileSync("./mocks/ci-test-repo-no-shallow.json", { encoding: "utf-8" }));
-const repo = await mockRepo({ fromSnapshot: ciTestRepo });
-it("should return if repo is undefined", async () => {
-    const projectId = await generateProjectId({ repo: undefined, projectPath: "mocked_project_path" });
-    expect(projectId).toBeUndefined();
-});
-it("should generate a project id", async () => {
-    const projectId = await generateProjectId({ repo, projectPath: "mocked_project_path" });
-    expect(projectId).toBe("432d7ef29c510e99d95e2d14ef57a0797a1603859b5a851b7dff7e77161b8c08");
-});
-it("should return undefined if repoMeta contains error", async () => {
-    await repo.nodeishFs.rm("/.git", { recursive: true });
-    const projectId = await generateProjectId({
-        repo: repo,
-        projectPath: "mocked_project_path",
-    });
-    expect(projectId).toBeUndefined();
-});

package/dist/migrations/migrateToDirectory.d.ts

@@ -1,10 +0,0 @@
-import type { NodeishFilesystem } from "@lix-js/fs";
-/**
- * Migrates to the new project directory structure
- * https://github.com/opral/monorepo/issues/1678
- */
-export declare const maybeMigrateToDirectory: (args: {
-    nodeishFs: NodeishFilesystem;
-    projectPath: string;
-}) => Promise<void>;
-//# sourceMappingURL=migrateToDirectory.d.ts.map

package/dist/migrations/migrateToDirectory.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"migrateToDirectory.d.ts","sourceRoot":"","sources":["../../src/migrations/migrateToDirectory.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAA;AAEnD;;;GAGG;AACH,eAAO,MAAM,uBAAuB,SAAgB;IACnD,SAAS,EAAE,iBAAiB,CAAA;IAC5B,WAAW,EAAE,MAAM,CAAA;CACnB,kBA6BA,CAAA"}

package/dist/migrations/migrateToDirectory.js

@@ -1,48 +0,0 @@
-import { tryCatch } from "@inlang/result";
-/**
- * Migrates to the new project directory structure
- * https://github.com/opral/monorepo/issues/1678
- */
-export const maybeMigrateToDirectory = async (args) => {
-    // the migration assumes that the projectPath ends with project.inlang
-    if (args.projectPath.endsWith("project.inlang") === false) {
-        return;
-    }
-    // we assume that stat will throw when the directory does not exist
-    const projectDirectory = await tryCatch(() => args.nodeishFs.stat(args.projectPath));
-    // the migration has already been conducted.
-    if (projectDirectory.data) {
-        return;
-    }
-    const settingsFile = await tryCatch(() => args.nodeishFs.readFile(args.projectPath + ".json", { encoding: "utf-8" }));
-    // the settings file does not exist or something else is wrong, let loadProject handle it
-    if (settingsFile.error) {
-        return;
-    }
-    await args.nodeishFs.mkdir(args.projectPath);
-    await args.nodeishFs.writeFile(`${args.projectPath}/settings.json`, settingsFile.data);
-    await args.nodeishFs.writeFile(args.projectPath + ".README.md", readme);
-    // eslint-disable-next-line no-console
-    // console.log("🔔 migrated project.inlang to directory")
-};
-const readme = `
-# DELETE THE \`project.inlang.json\` FILE
-
-The \`project.inlang.json\` file is now contained in a project directory e.g. \`project.inlang/settings.json\`.
-
-
-## What you need to do
-
-1. Update the inlang CLI (if you use it) to use the new path \`project.inlang\` instead of \`project.inlang.json\`.
-2. Delete the \`project.inlang.json\` file.
-
-
-## Why is this happening?
-
-See this RFC https://docs.google.com/document/d/1OYyA1wYfQRbIJOIBDliYoWjiUlkFBNxH_U2R4WpVRZ4/edit#heading=h.pecv6xb7ial6 
-and the following GitHub issue for more information https://github.com/opral/monorepo/issues/1678.
-
-- Monorepo support https://github.com/opral/monorepo/discussions/258. 
-- Required for many other future features like caching, first class offline support, and more. 
-- Stablize the inlang project format.
-`;

package/dist/migrations/migrateToDirectory.test.d.ts

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