@inlang/sdk 0.36.3 → 2.0.0-beta.1

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

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

package/dist/migrations/migrateToDirectory.test.js

@@ -1,48 +0,0 @@
-import { test, expect, vi } from "vitest";
-import { maybeMigrateToDirectory } from "./migrateToDirectory.js";
-import { createNodeishMemoryFs } from "@lix-js/fs";
-test("it should return if the settings file has an error (let loadProject handle it)", async () => {
-    const projectPath = "./project.inlang";
-    const mockFs = {
-        stat: vi.fn(() => { }),
-        readFile: vi.fn(() => {
-            throw Error();
-        }),
-    };
-    await maybeMigrateToDirectory({ nodeishFs: mockFs, projectPath });
-    // something goes wrong in readFile
-    expect(mockFs.readFile).toHaveBeenCalled();
-});
-test("it should create the project directory if it does not exist and a project settings file exists", async () => {
-    const projectPath = "./project.inlang";
-    const mockFs = {
-        readFile: vi.fn(() => `{
-			"sourceLanguageTag": "en",
-			"languageTags": ["en", "de"],
-			"modules": []
-		}`),
-        stat: vi.fn(() => {
-            throw Error();
-        }),
-        mkdir: vi.fn(),
-        writeFile: vi.fn(),
-    };
-    await maybeMigrateToDirectory({ nodeishFs: mockFs, projectPath });
-    expect(mockFs.mkdir).toHaveBeenCalled();
-    expect(mockFs.writeFile).toHaveBeenCalled();
-});
-test("it should write the settings file to the new path", async () => {
-    const fs = createNodeishMemoryFs();
-    const mockSettings = {
-        sourceLanguageTag: "en",
-        languageTags: ["en", "de"],
-        modules: [],
-    };
-    await fs.writeFile("./project.inlang.json", JSON.stringify(mockSettings));
-    await maybeMigrateToDirectory({ nodeishFs: fs, projectPath: "./project.inlang" });
-    const migratedSettingsFile = await fs.readFile("./project.inlang/settings.json", {
-        encoding: "utf-8",
-    });
-    expect(migratedSettingsFile).toEqual(JSON.stringify(mockSettings));
-    expect(await fs.stat("./project.inlang.README.md")).toBeDefined();
-});

package/dist/parseConfig.d.ts

@@ -1,8 +0,0 @@
-import { ProjectSettings } from "./versionedInterfaces.js";
-import type { Result } from "@inlang/result";
-export declare class ParseConfigError extends Error {
-    #private;
-    constructor(message: string, cause?: string);
-}
-export declare const parseSettings: (config: ProjectSettings) => Result<ProjectSettings, ParseConfigError>;
-//# sourceMappingURL=parseConfig.d.ts.map

package/dist/parseConfig.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"parseConfig.d.ts","sourceRoot":"","sources":["../src/parseConfig.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAA;AAC1D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAA;AAG5C,qBAAa,gBAAiB,SAAQ,KAAK;;gBAG9B,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM;CAK3C;AAKD,eAAO,MAAM,aAAa,WACjB,eAAe,KACrB,MAAM,CAAC,eAAe,EAAE,gBAAgB,CAe1C,CAAA"}

package/dist/parseConfig.js

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

package/dist/persistence/batchedIO.d.ts

@@ -1,11 +0,0 @@
-/**
- * State machine to convert async save() into batched async save()
- * states = idle -> acquiring -> saving -> idle
- * idle = nothing queued, ready to acquire lock.
- * aquiring = waiting to acquire a lock: requests go into the queue.
- * saving = lock is acquired, save has begun: new requests go into the next batch.
- * The next batch should not acquire the lock while current save is in progress.
- * Queued requests are only resolved when the save completes.
- */
-export declare function batchedIO(acquireLock: () => Promise<number>, releaseLock: (lock: number) => Promise<void>, save: () => Promise<void>): (id: string) => Promise<string>;
-//# sourceMappingURL=batchedIO.d.ts.map

package/dist/persistence/batchedIO.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"batchedIO.d.ts","sourceRoot":"","sources":["../../src/persistence/batchedIO.ts"],"names":[],"mappings":"AAGA;;;;;;;;GAQG;AACH,wBAAgB,SAAS,CACxB,WAAW,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,EAClC,WAAW,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,EAC5C,IAAI,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,GACvB,CAAC,EAAE,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,CA+CjC"}

package/dist/persistence/batchedIO.js

@@ -1,49 +0,0 @@
-import _debug from "debug";
-const debug = _debug("sdk:batchedIO");
-/**
- * State machine to convert async save() into batched async save()
- * states = idle -> acquiring -> saving -> idle
- * idle = nothing queued, ready to acquire lock.
- * aquiring = waiting to acquire a lock: requests go into the queue.
- * saving = lock is acquired, save has begun: new requests go into the next batch.
- * The next batch should not acquire the lock while current save is in progress.
- * Queued requests are only resolved when the save completes.
- */
-export function batchedIO(acquireLock, releaseLock, save) {
-    // 3-state machine
-    let state = "idle";
-    const queue = [];
-    // initialize nextBatch lazily, reset after saving
-    let nextBatch = undefined;
-    // batched save function
-    return async (id) => {
-        if (state === "idle") {
-            state = "acquiring";
-            const lock = await acquireLock();
-            state = "saving";
-            await save();
-            await releaseLock(lock);
-            resolveQueued();
-            nextBatch = undefined;
-            state = "idle";
-            return id;
-        }
-        else if (state === "acquiring") {
-            return new Promise((resolve, reject) => {
-                queue.push({ id, resolve, reject });
-            });
-        }
-        else {
-            // state === "saving"
-            nextBatch = nextBatch ?? batchedIO(acquireLock, releaseLock, save);
-            return await nextBatch(id);
-        }
-    };
-    function resolveQueued() {
-        debug("batched", queue.length + 1);
-        for (const { id, resolve } of queue) {
-            resolve(id);
-        }
-        queue.length = 0;
-    }
-}

package/dist/persistence/batchedIO.test.d.ts

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

package/dist/persistence/batchedIO.test.d.ts.map

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

package/dist/persistence/batchedIO.test.js

@@ -1,56 +0,0 @@
-import { describe, it, expect, vi } from "vitest";
-import { sleep } from "../test-utilities/sleep.js";
-import { batchedIO } from "./batchedIO.js";
-let locked = false;
-const instrumentAquireLockStart = vi.fn();
-async function mockAquireLock() {
-    instrumentAquireLockStart();
-    let pollCount = 0;
-    while (locked && pollCount++ < 100) {
-        await sleep(10);
-    }
-    if (locked) {
-        throw new Error("Timeout acquiring lock");
-    }
-    await sleep(10);
-    locked = true;
-    return 69;
-}
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-async function mockReleaseLock(_) {
-    sleep(10);
-    locked = false;
-}
-const instrumentSaveStart = vi.fn();
-const instrumentSaveEnd = vi.fn();
-async function mockSave() {
-    instrumentSaveStart();
-    await sleep(50);
-    instrumentSaveEnd();
-}
-describe("batchedIO", () => {
-    it("queues 2 requests while waiting for lock and pushes 2 more to the next batch", async () => {
-        const save = batchedIO(mockAquireLock, mockReleaseLock, mockSave);
-        const p1 = save("1");
-        const p2 = save("2");
-        await sleep(5);
-        expect(instrumentAquireLockStart).toHaveBeenCalledTimes(1);
-        expect(instrumentSaveStart).not.toHaveBeenCalled();
-        await sleep(10);
-        expect(instrumentSaveStart).toHaveBeenCalled();
-        expect(instrumentSaveEnd).not.toHaveBeenCalled();
-        const p3 = save("3");
-        const p4 = save("4");
-        expect(instrumentAquireLockStart).toHaveBeenCalledTimes(2);
-        expect(locked).toBe(true);
-        await sleep(50);
-        expect(instrumentSaveEnd).toHaveBeenCalled();
-        expect(await p1).toBe("1");
-        expect(await p2).toBe("2");
-        expect(instrumentSaveStart).toHaveBeenCalledTimes(1);
-        expect(await p3).toBe("3");
-        expect(await p4).toBe("4");
-        expect(instrumentAquireLockStart).toHaveBeenCalledTimes(2);
-        expect(instrumentSaveStart).toHaveBeenCalledTimes(2);
-    });
-});

package/dist/persistence/filelock/acquireFileLock.d.ts

@@ -1,3 +0,0 @@
-import { type NodeishFilesystem } from "@lix-js/fs";
-export declare function acquireFileLock(fs: NodeishFilesystem, lockDirPath: string, lockOrigin: string, tryCount?: number): Promise<number>;
-//# sourceMappingURL=acquireFileLock.d.ts.map

package/dist/persistence/filelock/acquireFileLock.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"acquireFileLock.d.ts","sourceRoot":"","sources":["../../../src/persistence/filelock/acquireFileLock.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,iBAAiB,EAAE,MAAM,YAAY,CAAA;AAQnD,wBAAsB,eAAe,CACpC,EAAE,EAAE,iBAAiB,EACrB,WAAW,EAAE,MAAM,EACnB,UAAU,EAAE,MAAM,EAClB,QAAQ,GAAE,MAAU,GAClB,OAAO,CAAC,MAAM,CAAC,CAmHjB"}

package/dist/persistence/filelock/acquireFileLock.js

@@ -1,111 +0,0 @@
-import {} from "@lix-js/fs";
-import _debug from "debug";
-const debug = _debug("sdk:fileLock");
-const maxRetries = 10;
-const nProbes = 50;
-const probeInterval = 100;
-export async function acquireFileLock(fs, lockDirPath, lockOrigin, tryCount = 0) {
-    if (tryCount > maxRetries) {
-        throw new Error(`${lockOrigin} exceeded maximum retries (${maxRetries}) to acquire lockfile ${tryCount}`);
-    }
-    try {
-        debug(lockOrigin + " tries to acquire a lockfile Retry Nr.: " + tryCount);
-        await fs.mkdir(lockDirPath);
-        // NOTE: fs.stat does not need to be atomic since mkdir would crash atomically - if we are here its save to consider the lock held by this process
-        const stats = await fs.stat(lockDirPath);
-        debug(lockOrigin + " acquired a lockfile Retry Nr.: " + tryCount);
-        return stats.mtimeMs;
-    }
-    catch (error) {
-        if (error.code !== "EEXIST") {
-            // NOTE in case we have an EEXIST - this is an expected error: the folder existed - another process already acquired the lock. Rethrow all other errors
-            throw error;
-        }
-    }
-    // land here if the lockDirPath already exists => lock is held by other process
-    let currentLockTime;
-    try {
-        const stats = await fs.stat(lockDirPath);
-        currentLockTime = stats.mtimeMs;
-    }
-    catch (fstatError) {
-        if (fstatError.code === "ENOENT") {
-            // lock file seems to be gone :) - lets try again
-            debug(lockOrigin + " tryCount++ lock file seems to be gone :) - lets try again " + tryCount);
-            return acquireFileLock(fs, lockDirPath, lockOrigin, tryCount + 1);
-        }
-        throw fstatError;
-    }
-    debug(lockOrigin +
-        " tries to acquire a lockfile  - lock currently in use... starting probe phase " +
-        tryCount);
-    return new Promise((resolve, reject) => {
-        let probeCounts = 0;
-        const scheduleProbationTimeout = () => {
-            setTimeout(async () => {
-                probeCounts += 1;
-                let lockFileStats = undefined;
-                try {
-                    debug(lockOrigin + " tries to acquire a lockfile - check if the lock is free now " + tryCount);
-                    // alright lets give it another try
-                    lockFileStats = await fs.stat(lockDirPath);
-                }
-                catch (fstatError) {
-                    if (fstatError.code === "ENOENT") {
-                        debug(lockOrigin +
-                            " tryCount++ in Promise - tries to acquire a lockfile - lock file seems to be free now - try to acquire " +
-                            tryCount);
-                        const lock = acquireFileLock(fs, lockDirPath, lockOrigin, tryCount + 1);
-                        return resolve(lock);
-                    }
-                    return reject(fstatError);
-                }
-                // still the same locker! -
-                if (lockFileStats.mtimeMs === currentLockTime) {
-                    if (probeCounts >= nProbes) {
-                        // ok maximum lock time ran up (we waitetd nProbes * probeInterval) - we consider the lock to be stale
-                        debug(lockOrigin +
-                            " tries to acquire a lockfile  - lock not free - but stale lets drop it" +
-                            tryCount);
-                        try {
-                            await fs.rmdir(lockDirPath);
-                        }
-                        catch (rmLockError) {
-                            if (rmLockError.code === "ENOENT") {
-                                // lock already gone?
-                                // Option 1: The "stale process" decided to get rid of it
-                                // Option 2: Another process acquiring the lock and detected a stale one as well
-                            }
-                            return reject(rmLockError);
-                        }
-                        try {
-                            debug(lockOrigin +
-                                " tryCount++ same locker - try to acquire again after removing stale lock " +
-                                tryCount);
-                            const lock = await acquireFileLock(fs, lockDirPath, lockOrigin, tryCount + 1);
-                            return resolve(lock);
-                        }
-                        catch (lockAquireException) {
-                            return reject(lockAquireException);
-                        }
-                    }
-                    else {
-                        // lets schedule a new probation
-                        return scheduleProbationTimeout();
-                    }
-                }
-                else {
-                    try {
-                        debug(lockOrigin + " tryCount++ different locker - try to acquire again " + tryCount);
-                        const lock = await acquireFileLock(fs, lockDirPath, lockOrigin, tryCount + 1);
-                        return resolve(lock);
-                    }
-                    catch (error) {
-                        return reject(error);
-                    }
-                }
-            }, probeInterval);
-        };
-        scheduleProbationTimeout();
-    });
-}

package/dist/persistence/filelock/releaseLock.d.ts

@@ -1,3 +0,0 @@
-import { type NodeishFilesystem } from "@lix-js/fs";
-export declare function releaseLock(fs: NodeishFilesystem, lockDirPath: string, lockOrigin: string, lockTime: number): Promise<void>;
-//# sourceMappingURL=releaseLock.d.ts.map

package/dist/persistence/filelock/releaseLock.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"releaseLock.d.ts","sourceRoot":"","sources":["../../../src/persistence/filelock/releaseLock.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,iBAAiB,EAAE,MAAM,YAAY,CAAA;AAInD,wBAAsB,WAAW,CAChC,EAAE,EAAE,iBAAiB,EACrB,WAAW,EAAE,MAAM,EACnB,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,iBAoBhB"}

package/dist/persistence/filelock/releaseLock.js

@@ -1,24 +0,0 @@
-import {} from "@lix-js/fs";
-import _debug from "debug";
-const debug = _debug("sdk:fileLock");
-export async function releaseLock(fs, lockDirPath, lockOrigin, lockTime) {
-    debug(lockOrigin + " releasing the lock ");
-    try {
-        const stats = await fs.stat(lockDirPath);
-        // I believe this check associates the lock with the aquirer
-        if (stats.mtimeMs === lockTime) {
-            // NOTE: since we have to use a timeout for stale detection (uTimes is not exposed via mermoryfs) the check for the locktime is not sufficient and can fail in rare cases when another process accuires a lock that was identifiert as tale between call to fs.state and rmDir
-            await fs.rmdir(lockDirPath);
-        }
-    }
-    catch (statError) {
-        debug(lockOrigin + " couldn't release the lock");
-        if (statError.code === "ENOENT") {
-            // ok seeks like the log was released by someone else
-            debug(lockOrigin + " WARNING - the lock was released by a different process");
-            return;
-        }
-        debug(statError);
-        throw statError;
-    }
-}

package/dist/persistence/store.d.ts

@@ -1,107 +0,0 @@
-import type { MessageBundle } from "../v2/types.js";
-import { type NodeishFilesystem } from "@lix-js/fs";
-import type { StoreApi } from "./storeApi.js";
-export declare function openStore(args: {
-    projectPath: string;
-    nodeishFs: NodeishFilesystem;
-    locales: string[];
-}): Promise<StoreApi>;
-export declare function readJSON(args: {
-    filePath: string;
-    nodeishFs: NodeishFilesystem;
-}): Promise<{
-    id: string;
-    alias: Record<string, string>;
-    messages: {
-        selectors: {
-            annotation?: {
-                type: "function";
-                name: string;
-                options: {
-                    name: string;
-                    value: {
-                        type: "literal";
-                        value: string;
-                    } | {
-                        type: "variable";
-                        name: string;
-                    };
-                }[];
-            } | undefined;
-            type: "expression";
-            arg: {
-                type: "literal";
-                value: string;
-            } | {
-                type: "variable";
-                name: string;
-            };
-        }[];
-        variants: {
-            match: string[];
-            pattern: ({
-                type: "text";
-                value: string;
-            } | {
-                annotation?: {
-                    type: "function";
-                    name: string;
-                    options: {
-                        name: string;
-                        value: {
-                            type: "literal";
-                            value: string;
-                        } | {
-                            type: "variable";
-                            name: string;
-                        };
-                    }[];
-                } | undefined;
-                type: "expression";
-                arg: {
-                    type: "literal";
-                    value: string;
-                } | {
-                    type: "variable";
-                    name: string;
-                };
-            })[];
-        }[];
-        locale: string;
-        declarations: {
-            type: "input";
-            name: string;
-            value: {
-                annotation?: {
-                    type: "function";
-                    name: string;
-                    options: {
-                        name: string;
-                        value: {
-                            type: "literal";
-                            value: string;
-                        } | {
-                            type: "variable";
-                            name: string;
-                        };
-                    }[];
-                } | undefined;
-                type: "expression";
-                arg: {
-                    type: "literal";
-                    value: string;
-                } | {
-                    type: "variable";
-                    name: string;
-                };
-            };
-        }[];
-    }[];
-}[]>;
-export declare function writeJSON(args: {
-    filePath: string;
-    nodeishFs: NodeishFilesystem;
-    messages: MessageBundle[];
-    locales: string[];
-}): Promise<void>;
-//# sourceMappingURL=store.d.ts.map

package/dist/persistence/store.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../../src/persistence/store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAA;AAEnD,OAAO,EAAc,KAAK,iBAAiB,EAAE,MAAM,YAAY,CAAA;AAI/D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA;AAK7C,wBAAsB,SAAS,CAAC,IAAI,EAAE;IACrC,WAAW,EAAE,MAAM,CAAA;IACnB,SAAS,EAAE,iBAAiB,CAAA;IAC5B,OAAO,EAAE,MAAM,EAAE,CAAA;CACjB,GAAG,OAAO,CAAC,QAAQ,CAAC,CA0DpB;AAED,wBAAsB,QAAQ,CAAC,IAAI,EAAE;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,iBAAiB,CAAA;CAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KActF;AAED,wBAAsB,SAAS,CAAC,IAAI,EAAE;IACrC,QAAQ,EAAE,MAAM,CAAA;IAChB,SAAS,EAAE,iBAAiB,CAAA;IAC5B,QAAQ,EAAE,aAAa,EAAE,CAAA;IACzB,OAAO,EAAE,MAAM,EAAE,CAAA;CACjB,iBAYA"}

package/dist/persistence/store.js

@@ -1,99 +0,0 @@
-import { addSlots, removeSlots, injectJSONNewlines } from "../v2/helper.js";
-import { getDirname } from "@lix-js/fs";
-import { acquireFileLock } from "./filelock/acquireFileLock.js";
-import { releaseLock } from "./filelock/releaseLock.js";
-import { batchedIO } from "./batchedIO.js";
-import _debug from "debug";
-const debug = _debug("sdk:store");
-export async function openStore(args) {
-    const nodeishFs = args.nodeishFs;
-    const filePath = args.projectPath + "/messages.json";
-    const lockDirPath = args.projectPath + "/messagelock";
-    // the index holds the in-memory state
-    // TODO: reload when file changes on disk
-    // https://github.com/opral/inlang-message-sdk/issues/80
-    let index = await load();
-    const batchedSave = batchedIO(acquireSaveLock, releaseSaveLock, save);
-    return {
-        messageBundles: {
-            reload: async () => {
-                index.clear();
-                index = await load();
-            },
-            get: async (args) => {
-                return index.get(args.id);
-            },
-            set: async (args) => {
-                index.set(args.data.id, args.data);
-                await batchedSave(args.data.id);
-            },
-            delete: async (args) => {
-                index.delete(args.id);
-                await batchedSave(args.id);
-            },
-            getAll: async () => {
-                return [...index.values()];
-            },
-        },
-    };
-    // load and save messages from file system atomically
-    // using a lock file to prevent partial reads and writes
-    async function load() {
-        const lockTime = await acquireFileLock(nodeishFs, lockDirPath, "load");
-        const messages = await readJSON({ filePath, nodeishFs: nodeishFs });
-        const index = new Map(messages.map((message) => [message.id, message]));
-        await releaseLock(nodeishFs, lockDirPath, "load", lockTime);
-        return index;
-    }
-    async function acquireSaveLock() {
-        return await acquireFileLock(nodeishFs, lockDirPath, "save");
-    }
-    async function releaseSaveLock(lock) {
-        return await releaseLock(nodeishFs, lockDirPath, "save", lock);
-    }
-    async function save() {
-        await writeJSON({
-            filePath,
-            nodeishFs: nodeishFs,
-            messages: [...index.values()],
-            locales: args.locales,
-        });
-    }
-}
-export async function readJSON(args) {
-    let result = [];
-    debug("loadAll", args.filePath);
-    try {
-        const file = await args.nodeishFs.readFile(args.filePath, { encoding: "utf-8" });
-        result = JSON.parse(file);
-    }
-    catch (error) {
-        if (error?.code !== "ENOENT") {
-            debug("loadMessages", error);
-            throw error;
-        }
-    }
-    return result.map(removeSlots);
-}
-export async function writeJSON(args) {
-    debug("saveall", args.filePath);
-    try {
-        await createDirectoryIfNotExits(getDirname(args.filePath), args.nodeishFs);
-        const output = injectJSONNewlines(JSON.stringify(args.messages.map((bundle) => addSlots(bundle, args.locales))));
-        await args.nodeishFs.writeFile(args.filePath, output);
-    }
-    catch (error) {
-        debug("saveMessages", error);
-        throw error;
-    }
-}
-async function createDirectoryIfNotExits(path, nodeishFs) {
-    try {
-        await nodeishFs.mkdir(path, { recursive: true });
-    }
-    catch (error) {
-        if (error.code !== "EEXIST") {
-            throw error;
-        }
-    }
-}

package/dist/persistence/store.test.d.ts

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

package/dist/persistence/store.test.d.ts.map

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