@inlang/sdk 0.34.3 → 0.34.5

package/dist/persistence/filelock/acquireFileLock.js

@@ -0,0 +1,109 @@
+import {} from "@lix-js/fs";
+import _debug from "debug";
+const debug = _debug("sdk:acquireFileLock");
+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 (5) to acquire lockfile " + tryCount);
+    }
+    try {
+        debug(lockOrigin + " tries to acquire a lockfile Retry Nr.: " + tryCount);
+        await fs.mkdir(lockDirPath);
+        const stats = await fs.stat(lockDirPath);
+        debug(lockOrigin + " acquired a lockfile Retry Nr.: " + tryCount);
+        return stats.mtimeMs;
+    }
+    catch (error) {
+        if (error.code !== "EEXIST") {
+            // we only expect the error that the file exists already (locked by other process)
+            throw error;
+        }
+    }
+    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

@@ -0,0 +1,3 @@
+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

@@ -0,0 +1 @@
+{"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,iBAmBhB"}

package/dist/persistence/filelock/releaseLock.js

@@ -0,0 +1,23 @@
+import {} from "@lix-js/fs";
+import _debug from "debug";
+const debug = _debug("sdk:releaseLock");
+export async function releaseLock(fs, lockDirPath, lockOrigin, lockTime) {
+    debug(lockOrigin + " releasing the lock ");
+    try {
+        const stats = await fs.stat(lockDirPath);
+        if (stats.mtimeMs === lockTime) {
+            // this can be corrupt as welll since the last getStat and the current a modification could have occured :-/
+            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/v2/index.d.ts

@@ -0,0 +1,2 @@
+export type * from "./types.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/v2/index.ts"],"names":[],"mappings":"AAAA,mBAAmB,YAAY,CAAA"}

package/dist/v2/index.js

@@ -0,0 +1 @@
+export {};

package/dist/v2/types.d.ts

@@ -0,0 +1,411 @@
+import { type Static } from "@sinclair/typebox";
+/**
+ * Follows the IETF BCP 47 language tag schema.
+ *
+ * @see https://www.ietf.org/rfc/bcp/bcp47.txt
+ * @see https://www.iana.org/assignments/language-subtag-registry/language-subtag-registry
+ */
+export type LanguageTag = Static<typeof LanguageTag>;
+/**
+ * Follows the IETF BCP 47 language tag schema with modifications.
+ * @see REAMDE.md file for more information on the validation.
+ */
+export declare const pattern = "^((?<grandfathered>(en-GB-oed|i-ami|i-bnn|i-default|i-enochian|i-hak|i-klingon|i-lux|i-mingo|i-navajo|i-pwn|i-tao|i-tay|i-tsu|sgn-BE-FR|sgn-BE-NL|sgn-CH-DE)|(art-lojban|cel-gaulish|no-bok|no-nyn|zh-guoyu|zh-hakka|zh-min|zh-min-nan|zh-xiang))|((?<language>([A-Za-z]{2,3}(-(?<extlang>[A-Za-z]{3}(-[A-Za-z]{3}){0,2}))?))(-(?<script>[A-Za-z]{4}))?(-(?<region>[A-Za-z]{2}|[0-9]{3}))?(-(?<variant>[A-Za-z0-9]{5,8}|[0-9][A-Za-z0-9]{3}))*))$";
+export declare const LanguageTag: import("@sinclair/typebox").TString;
+export type Literal = Static<typeof Literal>;
+export declare const Literal: import("@sinclair/typebox").TObject<{
+    type: import("@sinclair/typebox").TLiteral<"literal">;
+    value: import("@sinclair/typebox").TString;
+}>;
+/**
+ * A (text) element that is translatable and rendered to the UI.
+ */
+export type Text = Static<typeof Text>;
+export declare const Text: import("@sinclair/typebox").TObject<{
+    type: import("@sinclair/typebox").TLiteral<"text">;
+    value: import("@sinclair/typebox").TString;
+}>;
+export type VariableReference = Static<typeof VariableReference>;
+export declare const VariableReference: import("@sinclair/typebox").TObject<{
+    type: import("@sinclair/typebox").TLiteral<"variable">;
+    name: import("@sinclair/typebox").TString;
+}>;
+export type Option = Static<typeof Option>;
+export declare const Option: 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;
+    }>]>;
+}>;
+export type FunctionAnnotation = Static<typeof FunctionAnnotation>;
+export declare const FunctionAnnotation: 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;
+        }>]>;
+    }>>;
+}>;
+/**
+ * An expression is a reference to a variable or a function.
+ *
+ * Think of expressions as elements that are rendered to a
+ * text value during runtime.
+ */
+export type Expression = Static<typeof Expression>;
+export declare const Expression: 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;
+            }>]>;
+        }>>;
+    }>>;
+}>;
+/**
+ * A pattern is a sequence of elements that comprise
+ * a message that is rendered to the UI.
+ */
+export type Pattern = Static<typeof Pattern>;
+export declare const 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;
+            }>]>;
+        }>>;
+    }>>;
+}>]>>;
+/**
+ * A variant contains a pattern that is rendered to the UI.
+ */
+export type Variant = Static<typeof Variant>;
+export declare const Variant: 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;
+                }>]>;
+            }>>;
+        }>>;
+    }>]>>;
+}>;
+export type InputDeclaration = Static<typeof InputDeclaration>;
+export declare const InputDeclaration: 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;
+                }>]>;
+            }>>;
+        }>>;
+    }>;
+}>;
+export type Declaration = Static<typeof Declaration>;
+export declare const Declaration: 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;
+                }>]>;
+            }>>;
+        }>>;
+    }>;
+}>;
+export type Message = Static<typeof Message>;
+export declare const Message: 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;
+                    }>]>;
+                }>>;
+            }>>;
+        }>]>>;
+    }>>;
+}>;
+export type MessageBundle = Static<typeof MessageBundle>;
+export declare const MessageBundle: 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").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;
+                        }>]>;
+                    }>>;
+                }>>;
+            }>]>>;
+        }>>;
+    }>>;
+}>;
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +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"}

package/dist/v2/types.js

@@ -0,0 +1,69 @@
+import { Type } from "@sinclair/typebox";
+/**
+ * Follows the IETF BCP 47 language tag schema with modifications.
+ * @see REAMDE.md file for more information on the validation.
+ */
+export const pattern = "^((?<grandfathered>(en-GB-oed|i-ami|i-bnn|i-default|i-enochian|i-hak|i-klingon|i-lux|i-mingo|i-navajo|i-pwn|i-tao|i-tay|i-tsu|sgn-BE-FR|sgn-BE-NL|sgn-CH-DE)|(art-lojban|cel-gaulish|no-bok|no-nyn|zh-guoyu|zh-hakka|zh-min|zh-min-nan|zh-xiang))|((?<language>([A-Za-z]{2,3}(-(?<extlang>[A-Za-z]{3}(-[A-Za-z]{3}){0,2}))?))(-(?<script>[A-Za-z]{4}))?(-(?<region>[A-Za-z]{2}|[0-9]{3}))?(-(?<variant>[A-Za-z0-9]{5,8}|[0-9][A-Za-z0-9]{3}))*))$";
+export const LanguageTag = Type.String({
+    pattern: pattern,
+    description: "The language tag must be a valid IETF BCP 47 language tag.",
+    examples: ["en", "de", "en-US", "zh-Hans", "es-419"],
+});
+export const Literal = Type.Object({
+    type: Type.Literal("literal"),
+    value: Type.String(),
+});
+export const Text = Type.Object({
+    type: Type.Literal("text"),
+    value: Type.String(),
+});
+export const VariableReference = Type.Object({
+    type: Type.Literal("variable"),
+    name: Type.String(),
+});
+export const Option = Type.Object({
+    name: Type.String(),
+    value: Type.Union([Literal, VariableReference]),
+});
+export const FunctionAnnotation = Type.Object({
+    type: Type.Literal("function"),
+    name: Type.String(),
+    options: Type.Array(Option),
+});
+export const Expression = Type.Object({
+    type: Type.Literal("expression"),
+    arg: Type.Union([Literal, VariableReference]),
+    annotation: Type.Optional(FunctionAnnotation),
+});
+export const Pattern = Type.Array(Type.Union([Text, Expression]));
+export const Variant = Type.Object({
+    /**
+     * 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
+     */
+    // a match can always only be string-based because a string is what is rendered to the UI
+    match: Type.Array(Type.String()),
+    pattern: Pattern,
+});
+export const InputDeclaration = Type.Object({
+    type: Type.Literal("input"),
+    name: Type.String(),
+    //TODO make this generic so that only Variable-Ref Expressions are allowed
+    value: Expression,
+});
+export const Declaration = Type.Union([InputDeclaration]);
+export const Message = Type.Object({
+    locale: LanguageTag,
+    declarations: Type.Array(Declaration),
+    /**
+     * The order in which the selectors are placed determines the precedence of patterns.
+     */
+    selectors: Type.Array(Expression),
+    variants: Type.Array(Variant),
+});
+export const MessageBundle = Type.Object({
+    id: Type.String(),
+    alias: Type.Record(Type.String(), Type.String()),
+    messages: Type.Array(Message),
+});