@inlang/sdk 0.35.5 → 0.35.7

package/dist/v2/mocks/plural/bundle.js

@@ -1,4 +1,4 @@
-export const bundle = {
+export const pluralBundle = {
     id: "mock_bundle_human_id",
     alias: {
         default: "mock_bundle_alias",

package/dist/v2/mocks/plural/bundle.test.js

@@ -1,15 +1,15 @@
 /* eslint-disable @typescript-eslint/no-non-null-assertion */
 import { describe, it, expect } from "vitest";
-import { bundle } from "./bundle.js";
+import { pluralBundle } from "./bundle.js";
 import { MessageBundle } from "../../types.js";
 import { Value } from "@sinclair/typebox/value";
 describe("mock plural messageBundle", () => {
     it("is valid", () => {
-        const messageBundle = bundle;
+        const messageBundle = pluralBundle;
         expect(Value.Check(MessageBundle, messageBundle)).toBe(true);
-        expect(bundle.messages.length).toBe(2);
-        expect(bundle.messages[0].declarations.length).toBe(1);
-        expect(bundle.messages[0].selectors.length).toBe(1);
-        expect(bundle.messages[0].variants.length).toBe(3);
+        expect(pluralBundle.messages.length).toBe(2);
+        expect(pluralBundle.messages[0].declarations.length).toBe(1);
+        expect(pluralBundle.messages[0].selectors.length).toBe(1);
+        expect(pluralBundle.messages[0].variants.length).toBe(3);
     });
 });

package/dist/v2/shim.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Convert between v1 Message and v2 MessageBundle formats.
+ * Code adapted from https://github.com/opral/monorepo/pull/2655 legacy.ts
+ */
+import * as V2 from "./types.js";
+import * as V1 from "@inlang/message";
+/**
+ * @throws If the message cannot be represented in the v1 format
+ */
+export declare function toV1Message(bundle: V2.MessageBundle): V1.Message;
+export declare function fromV1Message(v1Message: V1.Message): V2.MessageBundle;
+//# sourceMappingURL=shim.d.ts.map

package/dist/v2/shim.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shim.d.ts","sourceRoot":"","sources":["../../src/v2/shim.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,MAAM,YAAY,CAAA;AAChC,OAAO,KAAK,EAAE,MAAM,iBAAiB,CAAA;AAErC;;GAEG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,EAAE,CAAC,aAAa,GAAG,EAAE,CAAC,OAAO,CA+BhE;AAwCD,wBAAgB,aAAa,CAAC,SAAS,EAAE,EAAE,CAAC,OAAO,GAAG,EAAE,CAAC,aAAa,CAgErE"}

package/dist/v2/shim.js

@@ -0,0 +1,151 @@
+/**
+ * Convert between v1 Message and v2 MessageBundle formats.
+ * Code adapted from https://github.com/opral/monorepo/pull/2655 legacy.ts
+ */
+import * as V2 from "./types.js";
+import * as V1 from "@inlang/message";
+/**
+ * @throws If the message cannot be represented in the v1 format
+ */
+export function toV1Message(bundle) {
+    const variants = [];
+    const selectorNames = new Set();
+    for (const message of bundle.messages) {
+        // collect all selector names
+        for (const selector of message.selectors.map(toV1Expression)) {
+            selectorNames.add(selector.name);
+        }
+        // collect all variants
+        for (const variant of message.variants) {
+            variants.push({
+                languageTag: message.locale,
+                match: variant.match,
+                pattern: toV1Pattern(variant.pattern),
+            });
+        }
+    }
+    const selectors = [...selectorNames].map((name) => ({
+        type: "VariableReference",
+        name,
+    }));
+    return {
+        id: bundle.id,
+        alias: bundle.alias,
+        variants,
+        selectors,
+    };
+}
+/**
+ * @throws If the pattern cannot be represented in the v1 format
+ */
+function toV1Pattern(pattern) {
+    return pattern.map((element) => {
+        switch (element.type) {
+            case "text": {
+                return {
+                    type: "Text",
+                    value: element.value,
+                };
+            }
+            case "expression": {
+                return toV1Expression(element);
+            }
+            default: {
+                throw new Error(`Unsupported pattern element type`);
+            }
+        }
+    });
+}
+function toV1Expression(expression) {
+    if (expression.annotation !== undefined)
+        throw new Error("Cannot convert an expression with an annotation to the v1 format");
+    if (expression.arg.type !== "variable") {
+        throw new Error("Can only convert variable references to the v1 format");
+    }
+    return {
+        type: "VariableReference",
+        name: expression.arg.name,
+    };
+}
+export function fromV1Message(v1Message) {
+    const languages = dedup(v1Message.variants.map((variant) => variant.languageTag));
+    const messages = languages.map((language) => {
+        //All variants that will be part of this message
+        const v1Variants = v1Message.variants.filter((variant) => variant.languageTag === language);
+        //find all selector names
+        const selectorNames = new Set();
+        for (const v1Selector of v1Message.selectors) {
+            selectorNames.add(v1Selector.name);
+        }
+        const selectors = [...selectorNames].map((name) => ({
+            type: "expression",
+            annotation: undefined,
+            arg: {
+                type: "variable",
+                name: name,
+            },
+        }));
+        //The set of variables that need to be defined - Certainly includes the selectors
+        const variableNames = new Set(selectorNames);
+        const variants = [];
+        for (const v1Variant of v1Variants) {
+            for (const element of v1Variant.pattern) {
+                if (element.type === "VariableReference") {
+                    variableNames.add(element.name);
+                }
+            }
+            variants.push({
+                match: v1Variant.match,
+                pattern: fromV1Pattern(v1Variant.pattern),
+            });
+        }
+        //Create an input declaration for each variable and selector we need
+        const declarations = [...variableNames].map((name) => ({
+            type: "input",
+            name,
+            value: {
+                type: "expression",
+                annotation: undefined,
+                arg: {
+                    type: "variable",
+                    name,
+                },
+            },
+        }));
+        return {
+            locale: language,
+            declarations,
+            selectors,
+            variants,
+        };
+    });
+    return {
+        id: v1Message.id,
+        alias: v1Message.alias,
+        messages,
+    };
+}
+function fromV1Pattern(pattern) {
+    return pattern.map((element) => {
+        switch (element.type) {
+            case "Text": {
+                return {
+                    type: "text",
+                    value: element.value,
+                };
+            }
+            case "VariableReference":
+                return {
+                    type: "expression",
+                    arg: {
+                        type: "variable",
+                        name: element.name,
+                    },
+                };
+        }
+    });
+}
+/**
+ * Dedups an array by converting it to a set and back
+ */
+const dedup = (arr) => [...new Set(arr)];

package/dist/v2/shim.test.d.ts

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

package/dist/v2/shim.test.d.ts.map

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

package/dist/v2/shim.test.js

@@ -0,0 +1,49 @@
+import { test, expect } from "vitest";
+import * as V2 from "./types.js";
+import * as V1 from "@inlang/message";
+import { createMessageBundle, createMessage } from "./helper.js";
+import { toV1Message, fromV1Message } from "./shim.js";
+import { Value } from "@sinclair/typebox/value";
+const bundle = createMessageBundle({
+    id: "hello_world",
+    messages: [
+        createMessage({ locale: "en", text: "Hello World!" }),
+        createMessage({ locale: "de", text: "Hallo Welt!" }),
+    ],
+});
+test("toV1Message and fromV1Message", () => {
+    expect(Value.Check(V2.MessageBundle, bundle)).toBe(true);
+    const v1Message = toV1Message(bundle);
+    expect(Value.Check(V1.Message, v1Message)).toBe(true);
+    expect(v1Message).toEqual({
+        id: "hello_world",
+        alias: {},
+        variants: [
+            {
+                languageTag: "en",
+                match: [],
+                pattern: [
+                    {
+                        type: "Text",
+                        value: "Hello World!",
+                    },
+                ],
+            },
+            {
+                languageTag: "de",
+                match: [],
+                pattern: [
+                    {
+                        type: "Text",
+                        value: "Hallo Welt!",
+                    },
+                ],
+            },
+        ],
+        selectors: [],
+    });
+    const v2MessageBundle = fromV1Message(v1Message);
+    expect(Value.Check(V2.MessageBundle, v2MessageBundle)).toBe(true);
+    expect(v2MessageBundle).toEqual(bundle);
+});
+test.todo("with variable references", () => { });

package/dist/v2/stubQueryApi.d.ts

@@ -0,0 +1,9 @@
+import type { MessageQueryApi, MessageLintReportsQueryApi } from "../api.js";
+/**
+ * noop implementation of the message query api for use with experimental.persistence = true.
+ * NOTE: If we implemented v2 shims for the old api we could use existing tests and make apps
+ * backwards compatible.
+ */
+export declare const stubMessagesQuery: MessageQueryApi;
+export declare const stubMessageLintReportsQuery: MessageLintReportsQueryApi;
+//# sourceMappingURL=stubQueryApi.d.ts.map

package/dist/v2/stubQueryApi.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stubQueryApi.d.ts","sourceRoot":"","sources":["../../src/v2/stubQueryApi.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,0BAA0B,EAAE,MAAM,WAAW,CAAA;AAE5E;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,EAAE,eAc/B,CAAA;AAED,eAAO,MAAM,2BAA2B,EAAE,0BAKzC,CAAA"}

package/dist/v2/stubQueryApi.js

@@ -0,0 +1,38 @@
+/**
+ * noop implementation of the message query api for use with experimental.persistence = true.
+ * NOTE: If we implemented v2 shims for the old api we could use existing tests and make apps
+ * backwards compatible.
+ */
+export const stubMessagesQuery = {
+    create: () => false,
+    // @ts-expect-error
+    get: subscribable(() => undefined),
+    // @ts-expect-error
+    getByDefaultAlias: subscribable(() => undefined),
+    // @ts-expect-error
+    includedMessageIds: subscribable(() => []),
+    // @ts-expect-error
+    getAll: subscribable(() => []),
+    update: () => false,
+    upsert: () => { },
+    delete: () => false,
+    setDelegate: () => { },
+};
+export const stubMessageLintReportsQuery = {
+    // @ts-expect-error
+    get: subscribable(() => []),
+    // @ts-expect-error
+    getAll: settleable(subscribable(() => [])),
+};
+// eslint-disable-next-line @typescript-eslint/ban-types
+function subscribable(fn) {
+    return Object.assign(fn, {
+        subscribe: () => { },
+    });
+}
+// eslint-disable-next-line @typescript-eslint/ban-types
+function settleable(fn) {
+    return Object.assign(fn, {
+        settled: async () => [],
+    });
+}

package/dist/v2/types.d.ts

@@ -408,4 +408,114 @@ export declare const MessageBundle: import("@sinclair/typebox").TObject<{
         }>>;
     }>>;
 }>;
+/**
+ * A MessageSlot is a placeholder for a message with a locale.
+ * This is useful to avoid merge conflicts when translations are added.
+ */
+export type MessageSlot = Static<typeof MessageSlot>;
+export declare const MessageSlot: import("@sinclair/typebox").TObject<{
+    locale: import("@sinclair/typebox").TString;
+    slot: import("@sinclair/typebox").TLiteral<true>;
+}>;
+export type MessageBundleWithSlots = Static<typeof MessageBundleWithSlots>;
+export declare const MessageBundleWithSlots: import("@sinclair/typebox").TObject<{
+    id: import("@sinclair/typebox").TString;
+    alias: import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TString>;
+    messages: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TObject<{
+        locale: import("@sinclair/typebox").TString;
+        declarations: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+            type: import("@sinclair/typebox").TLiteral<"input">;
+            name: import("@sinclair/typebox").TString;
+            value: import("@sinclair/typebox").TObject<{
+                type: import("@sinclair/typebox").TLiteral<"expression">;
+                arg: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TObject<{
+                    type: import("@sinclair/typebox").TLiteral<"literal">;
+                    value: import("@sinclair/typebox").TString;
+                }>, import("@sinclair/typebox").TObject<{
+                    type: import("@sinclair/typebox").TLiteral<"variable">;
+                    name: import("@sinclair/typebox").TString;
+                }>]>;
+                annotation: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
+                    type: import("@sinclair/typebox").TLiteral<"function">;
+                    name: import("@sinclair/typebox").TString;
+                    options: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+                        name: import("@sinclair/typebox").TString;
+                        value: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TObject<{
+                            type: import("@sinclair/typebox").TLiteral<"literal">;
+                            value: import("@sinclair/typebox").TString;
+                        }>, import("@sinclair/typebox").TObject<{
+                            type: import("@sinclair/typebox").TLiteral<"variable">;
+                            name: import("@sinclair/typebox").TString;
+                        }>]>;
+                    }>>;
+                }>>;
+            }>;
+        }>>;
+        /**
+         * The order in which the selectors are placed determines the precedence of patterns.
+         */
+        selectors: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+            type: import("@sinclair/typebox").TLiteral<"expression">;
+            arg: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TObject<{
+                type: import("@sinclair/typebox").TLiteral<"literal">;
+                value: import("@sinclair/typebox").TString;
+            }>, import("@sinclair/typebox").TObject<{
+                type: import("@sinclair/typebox").TLiteral<"variable">;
+                name: import("@sinclair/typebox").TString;
+            }>]>;
+            annotation: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
+                type: import("@sinclair/typebox").TLiteral<"function">;
+                name: import("@sinclair/typebox").TString;
+                options: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+                    name: import("@sinclair/typebox").TString;
+                    value: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TObject<{
+                        type: import("@sinclair/typebox").TLiteral<"literal">;
+                        value: import("@sinclair/typebox").TString;
+                    }>, import("@sinclair/typebox").TObject<{
+                        type: import("@sinclair/typebox").TLiteral<"variable">;
+                        name: import("@sinclair/typebox").TString;
+                    }>]>;
+                }>>;
+            }>>;
+        }>>;
+        variants: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+            /**
+             * The number of keys in each variant match MUST equal the number of expressions in the selectors.
+             *
+             * Inspired by: https://github.com/unicode-org/message-format-wg/blob/main/spec/formatting.md#pattern-selection
+             */
+            match: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+            pattern: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TObject<{
+                type: import("@sinclair/typebox").TLiteral<"text">;
+                value: import("@sinclair/typebox").TString;
+            }>, import("@sinclair/typebox").TObject<{
+                type: import("@sinclair/typebox").TLiteral<"expression">;
+                arg: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TObject<{
+                    type: import("@sinclair/typebox").TLiteral<"literal">;
+                    value: import("@sinclair/typebox").TString;
+                }>, import("@sinclair/typebox").TObject<{
+                    type: import("@sinclair/typebox").TLiteral<"variable">;
+                    name: import("@sinclair/typebox").TString;
+                }>]>;
+                annotation: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
+                    type: import("@sinclair/typebox").TLiteral<"function">;
+                    name: import("@sinclair/typebox").TString;
+                    options: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+                        name: import("@sinclair/typebox").TString;
+                        value: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TObject<{
+                            type: import("@sinclair/typebox").TLiteral<"literal">;
+                            value: import("@sinclair/typebox").TString;
+                        }>, import("@sinclair/typebox").TObject<{
+                            type: import("@sinclair/typebox").TLiteral<"variable">;
+                            name: import("@sinclair/typebox").TString;
+                        }>]>;
+                    }>>;
+                }>>;
+            }>]>>;
+        }>>;
+    }>, import("@sinclair/typebox").TObject<{
+        locale: import("@sinclair/typebox").TString;
+        slot: import("@sinclair/typebox").TLiteral<true>;
+    }>]>>;
+}>;
 //# sourceMappingURL=types.d.ts.map

package/dist/v2/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/v2/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,KAAK,MAAM,EAAE,MAAM,mBAAmB,CAAA;AAErD;;;;;GAKG;AACH,MAAM,MAAM,WAAW,GAAG,MAAM,CAAC,OAAO,WAAW,CAAC,CAAA;AACpD;;;GAGG;AAEH,eAAO,MAAM,OAAO,sbACga,CAAA;AAEpb,eAAO,MAAM,WAAW,qCAItB,CAAA;AAEF,MAAM,MAAM,OAAO,GAAG,MAAM,CAAC,OAAO,OAAO,CAAC,CAAA;AAC5C,eAAO,MAAM,OAAO;;;EAGlB,CAAA;AAEF;;GAEG;AACH,MAAM,MAAM,IAAI,GAAG,MAAM,CAAC,OAAO,IAAI,CAAC,CAAA;AACtC,eAAO,MAAM,IAAI;;;EAGf,CAAA;AAEF,MAAM,MAAM,iBAAiB,GAAG,MAAM,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAChE,eAAO,MAAM,iBAAiB;;;EAG5B,CAAA;AAEF,MAAM,MAAM,MAAM,GAAG,MAAM,CAAC,OAAO,MAAM,CAAC,CAAA;AAC1C,eAAO,MAAM,MAAM;;;;;;;;;EAGjB,CAAA;AAEF,MAAM,MAAM,kBAAkB,GAAG,MAAM,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAClE,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;EAI7B,CAAA;AAEF;;;;;GAKG;AACH,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,OAAO,UAAU,CAAC,CAAA;AAClD,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;EAIrB,CAAA;AASF;;;GAGG;AACH,MAAM,MAAM,OAAO,GAAG,MAAM,CAAC,OAAO,OAAO,CAAC,CAAA;AAC5C,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;KAA6C,CAAA;AAEjE;;GAEG;AACH,MAAM,MAAM,OAAO,GAAG,MAAM,CAAC,OAAO,OAAO,CAAC,CAAA;AAC5C,eAAO,MAAM,OAAO;IACnB;;;;OAIG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAIF,CAAA;AAEF,MAAM,MAAM,gBAAgB,GAAG,MAAM,CAAC,OAAO,gBAAgB,CAAC,CAAA;AAC9D,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;EAM3B,CAAA;AAgBF,MAAM,MAAM,WAAW,GAAG,MAAM,CAAC,OAAO,WAAW,CAAC,CAAA;AACpD,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAiC,CAAA;AAEzD,MAAM,MAAM,OAAO,GAAG,MAAM,CAAC,OAAO,OAAO,CAAC,CAAA;AAC5C,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAGnB;;OAEG;;;;;;;;;;;;;;;;;;;;;;;;;;QA1CH;;;;WAIG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyCF,CAAA;AAEF,MAAM,MAAM,aAAa,GAAG,MAAM,CAAC,OAAO,aAAa,CAAC,CAAA;AACxD,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QARzB;;WAEG;;;;;;;;;;;;;;;;;;;;;;;;;;YA1CH;;;;eAIG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgDF,CAAA"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/v2/types.ts"],"names":[],"mappings":"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"}

package/dist/v2/types.js

@@ -67,3 +67,12 @@ export const MessageBundle = Type.Object({
     alias: Type.Record(Type.String(), Type.String()),
     messages: Type.Array(Message),
 });
+export const MessageSlot = Type.Object({
+    locale: LanguageTag,
+    slot: Type.Literal(true),
+});
+export const MessageBundleWithSlots = Type.Object({
+    id: Type.String(),
+    alias: Type.Record(Type.String(), Type.String()),
+    messages: Type.Array(Type.Union([Message, MessageSlot])),
+});

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@inlang/sdk",
   "type": "module",
-  "version": "0.35.5",
+  "version": "0.35.7",
   "license": "Apache-2.0",
   "publishConfig": {
     "access": "public"
@@ -16,7 +16,8 @@
     "./test-utilities": "./dist/test-utilities/index.js",
     "./lint": "./dist/lint/index.js",
     "./messages": "./dist/messages/index.js",
-    "./v2": "./dist/v2/index.js"
+    "./v2": "./dist/v2/index.js",
+    "./v2-mocks": "./dist/v2/mocks/index.js"
   },
   "files": [
     "./dist",
@@ -33,15 +34,15 @@
     "murmurhash3js": "^3.0.1",
     "solid-js": "1.6.12",
     "throttle-debounce": "^5.0.0",
+    "@inlang/language-tag": "1.5.1",
     "@inlang/json-types": "1.1.0",
     "@inlang/message": "2.1.0",
-    "@inlang/language-tag": "1.5.1",
-    "@inlang/message-lint-rule": "1.4.7",
     "@inlang/module": "1.2.13",
     "@inlang/plugin": "2.4.13",
     "@inlang/project-settings": "2.4.2",
-    "@inlang/translatable": "1.3.1",
     "@inlang/result": "1.1.0",
+    "@inlang/translatable": "1.3.1",
+    "@inlang/message-lint-rule": "1.4.7",
     "@lix-js/client": "2.2.0",
     "@lix-js/fs": "2.1.0"
   },

package/src/api.ts

@@ -10,7 +10,7 @@ import type {
 	MessageLintReport,
 } from "./versionedInterfaces.js"
 import type { ResolvedPluginApi } from "./resolve-modules/plugins/types.js"
-import type * as V2 from "./v2/types.js"
+import type { StoreApi } from "./persistence/storeApi.js"
 
 export type InstalledPlugin = {
 	id: Plugin["id"]
@@ -58,18 +58,7 @@ export type InlangProject = {
 	}
 	// WIP V2 message apis
 	// use with project settings: experimental.persistence = true
-	messageBundles?: Query<V2.MessageBundle>
-	messages?: Query<V2.Message>
-	variants?: Query<V2.Variant>
-}
-
-/**
- * WIP template for async V2 crud interfaces
- * E.g. `await project.messageBundles.get({ id: "..." })`
- **/
-interface Query<T> {
-	get: (args: unknown) => Promise<T>
-	getAll: () => Promise<T[]>
+	store?: StoreApi
 }
 
 // const x = {} as InlangProject

package/src/createNewProject.test.ts

@@ -4,10 +4,7 @@ import { mockRepo } from "@lix-js/client"
 import { defaultProjectSettings } from "./defaultProjectSettings.js"
 import { loadProject } from "./loadProject.js"
 import { createMessage } from "./test-utilities/createMessage.js"
-
-function sleep(ms: number) {
-	return new Promise((resolve) => setTimeout(resolve, ms))
-}
+import { sleep } from "./test-utilities/sleep.js"
 
 describe("createNewProject", () => {
 	it("should throw if a path does not end with .inlang", async () => {

package/src/loadProject.test.ts

@@ -278,11 +278,15 @@ describe("initialization", () => {
 		expect(result.data).toBeDefined()
 	})
 
+	// TODO: fix this test
+	// https://github.com/opral/inlang-message-sdk/issues/76
+	// it doesn't work because failure to open the settings file doesn't throw
+	// errors are returned in project.errors()
 	it("should resolve from a windows path", async () => {
 		const repo = await mockRepo()
 		const fs = repo.nodeishFs
-		fs.mkdir("C:\\Users\\user\\project.inlang", { recursive: true })
-		fs.writeFile("C:\\Users\\user\\project.inlang\\settings.json", JSON.stringify(settings))
+		await fs.mkdir("C:\\Users\\user\\project.inlang", { recursive: true })
+		await fs.writeFile("C:\\Users\\user\\project.inlang\\settings.json", JSON.stringify(settings))
 
 		const result = await tryCatch(() =>
 			loadProject({