@inlang/sdk 0.1.0

package/dist/reactivity/map.d.ts

@@ -0,0 +1,66 @@
+declare var ReactiveMap: {
+    new (initial: any): {
+        "__#2@#keyTriggers": {
+            "__#1@#map": Map<any, any>;
+            dirty(key: any): void;
+            track(key: any): void;
+        };
+        "__#2@#valueTriggers": {
+            "__#1@#map": Map<any, any>;
+            dirty(key: any): void;
+            track(key: any): void;
+        };
+        has(key: any): boolean;
+        get(key: any): any;
+        readonly size: number;
+        keys(): IterableIterator<any>;
+        values(): IterableIterator<any>;
+        entries(): IterableIterator<[any, any]>;
+        set(key: any, value: any): any;
+        delete(key: any): boolean;
+        clear(): void;
+        forEach(callbackfn: any): void;
+        [Symbol.iterator](): IterableIterator<[any, any]>;
+        readonly [Symbol.toStringTag]: string;
+    };
+    readonly [Symbol.species]: MapConstructor;
+};
+declare var ReactiveWeakMap: {
+    new (initial: any): {
+        "__#3@#keyTriggers": {
+            "__#1@#map": Map<any, any>;
+            dirty(key: any): void;
+            track(key: any): void;
+        };
+        "__#3@#valueTriggers": {
+            "__#1@#map": Map<any, any>;
+            dirty(key: any): void;
+            track(key: any): void;
+        };
+        has(key: any): boolean;
+        get(key: any): any;
+        set(key: any, value: any): any;
+        delete(key: any): boolean;
+        readonly [Symbol.toStringTag]: string;
+    };
+};
+declare function createMap(initial: any): () => [any, any][];
+declare function createWeakMap(initial: any): {
+    "__#3@#keyTriggers": {
+        "__#1@#map": Map<any, any>;
+        dirty(key: any): void;
+        track(key: any): void;
+    };
+    "__#3@#valueTriggers": {
+        "__#1@#map": Map<any, any>;
+        dirty(key: any): void;
+        track(key: any): void;
+    };
+    has(key: any): boolean;
+    get(key: any): any;
+    set(key: any, value: any): any;
+    delete(key: any): boolean;
+    readonly [Symbol.toStringTag]: string;
+};
+export { ReactiveMap, ReactiveWeakMap, createMap, createWeakMap };
+//# sourceMappingURL=map.d.ts.map

package/dist/reactivity/map.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"map.d.ts","sourceRoot":"","sources":["../../src/reactivity/map.ts"],"names":[],"mappings":"AAQA,QAAA,IAAI,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;CA+Ed,CAAA;AACD,QAAA,IAAI,eAAe;;;;;;;;;;;;;;;;;;CAmClB,CAAA;AACD,iBAAS,SAAS,CAAC,OAAO,KAAA,sBAKzB;AACD,iBAAS,aAAa,CAAC,OAAO,KAAA;;;;;;;;;;;;;;;;EAE7B;AAED,OAAO,EAAE,WAAW,EAAE,eAAe,EAAE,SAAS,EAAE,aAAa,EAAE,CAAA"}

package/dist/reactivity/map.js

@@ -0,0 +1,143 @@
+// @ts-nocheck
+/* eslint-disable */
+import { batch } from "./solid.js";
+import { TriggerCache } from "./trigger.js";
+// src/index.ts
+var $KEYS = Symbol("track-keys");
+var ReactiveMap = class extends Map {
+    #keyTriggers = new TriggerCache();
+    #valueTriggers = new TriggerCache();
+    constructor(initial) {
+        super();
+        if (initial)
+            for (const v of initial)
+                super.set(v[0], v[1]);
+    }
+    // reads
+    has(key) {
+        this.#keyTriggers.track(key);
+        return super.has(key);
+    }
+    get(key) {
+        this.#valueTriggers.track(key);
+        return super.get(key);
+    }
+    get size() {
+        this.#keyTriggers.track($KEYS);
+        return super.size;
+    }
+    keys() {
+        this.#keyTriggers.track($KEYS);
+        return super.keys();
+    }
+    values() {
+        this.#keyTriggers.track($KEYS);
+        for (const v of super.keys())
+            this.#valueTriggers.track(v);
+        return super.values();
+    }
+    entries() {
+        this.#keyTriggers.track($KEYS);
+        for (const v of super.keys())
+            this.#valueTriggers.track(v);
+        return super.entries();
+    }
+    // writes
+    set(key, value) {
+        batch(() => {
+            if (super.has(key)) {
+                if (super.get(key) === value)
+                    return;
+            }
+            else {
+                this.#keyTriggers.dirty(key);
+                this.#keyTriggers.dirty($KEYS);
+            }
+            this.#valueTriggers.dirty(key);
+            super.set(key, value);
+        });
+        return this;
+    }
+    delete(key) {
+        const r = super.delete(key);
+        if (r) {
+            batch(() => {
+                this.#keyTriggers.dirty(key);
+                this.#keyTriggers.dirty($KEYS);
+                this.#valueTriggers.dirty(key);
+            });
+        }
+        return r;
+    }
+    clear() {
+        if (super.size) {
+            batch(() => {
+                for (const v of super.keys()) {
+                    this.#keyTriggers.dirty(v);
+                    this.#valueTriggers.dirty(v);
+                }
+                super.clear();
+                this.#keyTriggers.dirty($KEYS);
+            });
+        }
+    }
+    // callback
+    forEach(callbackfn) {
+        this.#keyTriggers.track($KEYS);
+        super.forEach((value, key) => callbackfn(value, key, this));
+    }
+    [Symbol.iterator]() {
+        return this.entries();
+    }
+};
+var ReactiveWeakMap = class extends WeakMap {
+    #keyTriggers = new TriggerCache(WeakMap);
+    #valueTriggers = new TriggerCache(WeakMap);
+    constructor(initial) {
+        super();
+        if (initial)
+            for (const v of initial)
+                super.set(v[0], v[1]);
+    }
+    has(key) {
+        this.#keyTriggers.track(key);
+        return super.has(key);
+    }
+    get(key) {
+        this.#valueTriggers.track(key);
+        return super.get(key);
+    }
+    set(key, value) {
+        batch(() => {
+            if (super.has(key)) {
+                if (super.get(key) === value)
+                    return;
+            }
+            else
+                this.#keyTriggers.dirty(key);
+            this.#valueTriggers.dirty(key);
+            super.set(key, value);
+        });
+        return this;
+    }
+    delete(key) {
+        const r = super.delete(key);
+        if (r) {
+            batch(() => {
+                this.#keyTriggers.dirty(key);
+                this.#valueTriggers.dirty(key);
+            });
+        }
+        return r;
+    }
+};
+function createMap(initial) {
+    const map = new ReactiveMap(initial);
+    return new Proxy(() => [...map], {
+        get: (_, b) => map[b],
+    });
+}
+function createWeakMap(initial) {
+    return new ReactiveWeakMap(initial);
+}
+export { ReactiveMap, ReactiveWeakMap, createMap, createWeakMap };

package/dist/reactivity/solid.d.ts

@@ -0,0 +1,12 @@
+import { DEV } from "solid-js/dist/solid.js";
+declare const createSignal: typeof import("solid-js").createSignal;
+declare const createMemo: typeof import("solid-js").createMemo;
+declare const createRoot: typeof import("solid-js").createRoot;
+declare const createEffect: typeof import("solid-js").createEffect;
+declare const observable: typeof import("solid-js").observable;
+declare const from: typeof import("solid-js").from;
+declare const batch: typeof import("solid-js").batch;
+declare const getListener: typeof import("solid-js").getListener;
+declare const onCleanup: typeof import("solid-js").onCleanup;
+export { createSignal, createMemo, createRoot, createEffect, observable, from, batch, getListener, onCleanup, DEV, };
+//# sourceMappingURL=solid.d.ts.map

package/dist/reactivity/solid.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"solid.d.ts","sourceRoot":"","sources":["../../src/reactivity/solid.ts"],"names":[],"mappings":"AAAA,OAAO,EAUN,GAAG,EAEH,MAAM,wBAAwB,CAAA;AAE/B,QAAA,MAAM,YAAY,wCAA6D,CAAA;AAC/E,QAAA,MAAM,UAAU,sCAAyD,CAAA;AACzE,QAAA,MAAM,UAAU,sCAAyD,CAAA;AACzE,QAAA,MAAM,YAAY,wCAA6D,CAAA;AAC/E,QAAA,MAAM,UAAU,sCAAyD,CAAA;AACzE,QAAA,MAAM,IAAI,gCAA6C,CAAA;AACvD,QAAA,MAAM,KAAK,iCAA+C,CAAA;AAC1D,QAAA,MAAM,WAAW,uCAA2D,CAAA;AAC5E,QAAA,MAAM,SAAS,qCAAuD,CAAA;AAEtE,OAAO,EACN,YAAY,EACZ,UAAU,EACV,UAAU,EACV,YAAY,EACZ,UAAU,EACV,IAAI,EACJ,KAAK,EACL,WAAW,EACX,SAAS,EACT,GAAG,GACH,CAAA"}

package/dist/reactivity/solid.js

@@ -0,0 +1,13 @@
+import { createSignal as _createSignal, createMemo as _createMemo, createRoot as _createRoot, createEffect as _createEffect, observable as _observable, batch as _batch, from as _from, getListener as _getListener, onCleanup as _onCleanup, DEV,
+// @ts-ignore
+ } from "solid-js/dist/solid.js";
+const createSignal = _createSignal;
+const createMemo = _createMemo;
+const createRoot = _createRoot;
+const createEffect = _createEffect;
+const observable = _observable;
+const from = _from;
+const batch = _batch;
+const getListener = _getListener;
+const onCleanup = _onCleanup;
+export { createSignal, createMemo, createRoot, createEffect, observable, from, batch, getListener, onCleanup, DEV, };

package/dist/reactivity/trigger.d.ts

@@ -0,0 +1,11 @@
+declare function createTrigger(): (() => void)[];
+declare var TriggerCache: {
+    new (mapConstructor?: MapConstructor): {
+        "__#1@#map": Map<any, any>;
+        dirty(key: any): void;
+        track(key: any): void;
+    };
+};
+declare function createTriggerCache(mapConstructor?: MapConstructor): ((key: any) => void)[];
+export { TriggerCache, createTrigger, createTriggerCache };
+//# sourceMappingURL=trigger.d.ts.map

package/dist/reactivity/trigger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trigger.d.ts","sourceRoot":"","sources":["../../src/reactivity/trigger.ts"],"names":[],"mappings":"AAYA,iBAAS,aAAa,mBAKrB;AACD,QAAA,IAAI,YAAY;;;;;;CAqBf,CAAA;AACD,iBAAS,kBAAkB,CAAC,cAAc,iBAAM,0BAG/C;AAED,OAAO,EAAE,YAAY,EAAE,aAAa,EAAE,kBAAkB,EAAE,CAAA"}

package/dist/reactivity/trigger.js

@@ -0,0 +1,46 @@
+// @ts-nocheck
+/* eslint-disable */
+import { createSignal, getListener, onCleanup, DEV } from "./solid.js";
+const noop = () => { };
+const isServer = false;
+// src/index.ts
+var triggerOptions = !isServer && DEV ? { equals: false, name: "trigger" } : { equals: false };
+var triggerCacheOptions = !isServer && DEV ? { equals: false, internal: true } : triggerOptions;
+function createTrigger() {
+    if (isServer) {
+        return [noop, noop];
+    }
+    return createSignal(void 0, triggerOptions);
+}
+var TriggerCache = class {
+    #map;
+    constructor(mapConstructor = Map) {
+        this.#map = new mapConstructor();
+    }
+    dirty(key) {
+        if (isServer)
+            return;
+        this.#map.get(key)?.$$();
+    }
+    track(key) {
+        if (!getListener())
+            return;
+        let trigger = this.#map.get(key);
+        if (!trigger) {
+            const [$, $$] = createSignal(void 0, triggerCacheOptions);
+            this.#map.set(key, (trigger = { $, $$, n: 1 }));
+        }
+        else
+            trigger.n++;
+        onCleanup(() => {
+            if (trigger.n-- === 1)
+                queueMicrotask(() => trigger.n === 0 && this.#map.delete(key));
+        });
+        trigger.$();
+    }
+};
+function createTriggerCache(mapConstructor = Map) {
+    const map = new TriggerCache(mapConstructor);
+    return [map.track.bind(map), map.dirty.bind(map)];
+}
+export { TriggerCache, createTrigger, createTriggerCache };

package/dist/resolve-modules/errors.d.ts

@@ -0,0 +1,34 @@
+export * from "./plugins/errors.js";
+export * from "./message-lint-rules/errors.js";
+export declare class ModuleError extends Error {
+    readonly Module: string;
+    constructor(message: string, options: {
+        module: string;
+        cause?: Error;
+    });
+}
+/**
+ * Error when a Module does not export any plugins or lint rules.
+ */
+export declare class ModuleHasNoExportsError extends ModuleError {
+    constructor(message: string, options: {
+        module: string;
+        cause?: Error;
+    });
+}
+/**
+ * Error when a Module cannot be imported.
+ */
+export declare class ModuleImportError extends ModuleError {
+    constructor(message: string, options: {
+        module: string;
+        cause: Error;
+    });
+}
+export declare class ModuleExportIsInvalidError extends ModuleError {
+    constructor(message: string, options: {
+        module: string;
+        cause?: Error;
+    });
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/resolve-modules/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/resolve-modules/errors.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAA;AACnC,cAAc,gCAAgC,CAAA;AAE9C,qBAAa,WAAY,SAAQ,KAAK;IACrC,SAAgB,MAAM,EAAE,MAAM,CAAA;gBAClB,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,KAAK,CAAA;KAAE;CAMvE;AAED;;GAEG;AACH,qBAAa,uBAAwB,SAAQ,WAAW;gBAC3C,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,KAAK,CAAA;KAAE;CAIvE;AAED;;GAEG;AACH,qBAAa,iBAAkB,SAAQ,WAAW;gBACrC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,KAAK,CAAA;KAAE;CAItE;AAED,qBAAa,0BAA2B,SAAQ,WAAW;gBAC9C,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,KAAK,CAAA;KAAE;CAIvE"}

package/dist/resolve-modules/errors.js

@@ -0,0 +1,35 @@
+export * from "./plugins/errors.js";
+export * from "./message-lint-rules/errors.js";
+export class ModuleError extends Error {
+    Module;
+    constructor(message, options) {
+        super(message);
+        this.name = "ModuleError";
+        this.Module = options.module;
+        this.cause = options.cause;
+    }
+}
+/**
+ * Error when a Module does not export any plugins or lint rules.
+ */
+export class ModuleHasNoExportsError extends ModuleError {
+    constructor(message, options) {
+        super(message, options);
+        this.name = "ModuleHasNoExportsError";
+    }
+}
+/**
+ * Error when a Module cannot be imported.
+ */
+export class ModuleImportError extends ModuleError {
+    constructor(message, options) {
+        super(message, options);
+        this.name = "ModuleImportError";
+    }
+}
+export class ModuleExportIsInvalidError extends ModuleError {
+    constructor(message, options) {
+        super(message, options);
+        this.name = "ModuleExportIsInvalidError";
+    }
+}

package/dist/resolve-modules/import.d.ts

@@ -0,0 +1,35 @@
+import type { NodeishFilesystemSubset } from "@inlang/plugin";
+/**
+ * Importing ES modules either from a local path, or from a url.
+ *
+ * - Name the import function `_import` to avoid shadowing the
+ *   native import function.
+ */
+export type ImportFunction = (uri: string) => Promise<any>;
+/**
+ * Creates the import function.
+ *
+ * This function is required to import modules from a local path.
+ *
+ * @example
+ *   const $import = createImport({ readFile: fs.readFile, fetch });
+ *   const module = await _import('./some-module.js');
+ */
+export declare function createImport(args: {
+    /** the fs from which the file can be read */
+    readFile: NodeishFilesystemSubset["readFile"];
+    /** http client implementation */
+    fetch: typeof fetch;
+}): (uri: string) => ReturnType<typeof $import>;
+declare function $import(uri: string, options: {
+    /**
+     * Required to import from a local path.
+     */
+    readFile: NodeishFilesystemSubset["readFile"];
+    /**
+     * Required to import via network.
+     */
+    fetch: typeof fetch;
+}): Promise<any>;
+export {};
+//# sourceMappingURL=import.d.ts.map

package/dist/resolve-modules/import.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"import.d.ts","sourceRoot":"","sources":["../../src/resolve-modules/import.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,gBAAgB,CAAA;AAG7D;;;;;GAKG;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,GAAG,CAAC,CAAA;AAE1D;;;;;;;;GAQG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE;IAClC,6CAA6C;IAC7C,QAAQ,EAAE,uBAAuB,CAAC,UAAU,CAAC,CAAA;IAC7C,iCAAiC;IACjC,KAAK,EAAE,OAAO,KAAK,CAAA;CACnB,GAAG,CAAC,GAAG,EAAE,MAAM,KAAK,UAAU,CAAC,OAAO,OAAO,CAAC,CAG9C;AAED,iBAAe,OAAO,CACrB,GAAG,EAAE,MAAM,EACX,OAAO,EAAE;IACR;;OAEG;IACH,QAAQ,EAAE,uBAAuB,CAAC,UAAU,CAAC,CAAA;IAC7C;;OAEG;IACH,KAAK,EAAE,OAAO,KAAK,CAAA;CACnB,GACC,OAAO,CAAC,GAAG,CAAC,CAwBd"}

package/dist/resolve-modules/import.js

@@ -0,0 +1,40 @@
+import { dedent } from "ts-dedent";
+import { normalizePath } from "@lix-js/fs";
+import { ModuleImportError } from "./errors.js";
+/**
+ * Creates the import function.
+ *
+ * This function is required to import modules from a local path.
+ *
+ * @example
+ *   const $import = createImport({ readFile: fs.readFile, fetch });
+ *   const module = await _import('./some-module.js');
+ */
+export function createImport(args) {
+    // resembles a native import api
+    return (uri) => $import(uri, args);
+}
+async function $import(uri, options) {
+    let moduleAsText;
+    if (uri.startsWith("http")) {
+        moduleAsText = await (await options.fetch(uri)).text();
+    }
+    else {
+        moduleAsText = await options.readFile(normalizePath(uri), { encoding: "utf-8" });
+    }
+    const moduleWithMimeType = "data:application/javascript," + encodeURIComponent(moduleAsText);
+    try {
+        return await import(/* @vite-ignore */ moduleWithMimeType);
+    }
+    catch (error) {
+        let message = `Error while importing ${uri}: ${error?.message ?? "Unknown error"}`;
+        if (error instanceof SyntaxError && uri.includes("jsdelivr")) {
+            message += dedent `\n\n
+Are you sure that the file exists on JSDelivr?
+
+The error indicates that the imported file does not exist on JSDelivr. For non-existent files, JSDelivr returns a 404 text that JS cannot parse as a module and throws a SyntaxError.
+			`;
+        }
+        throw new ModuleImportError(message, { module: uri, cause: error });
+    }
+}

package/dist/resolve-modules/import.test.d.ts

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

package/dist/resolve-modules/import.test.d.ts.map

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

package/dist/resolve-modules/import.test.js

@@ -0,0 +1,45 @@
+// @vitest-environment jsdom
+import { createNodeishMemoryFs } from "@lix-js/fs";
+import { describe, expect, it } from "vitest";
+import { createImport } from "./import.js";
+describe("$import", async () => {
+    const fs = createNodeishMemoryFs();
+    await fs.writeFile("./mock-module.js", `
+		export function hello() {
+			return "hello";
+		}
+		`);
+    // mock module in a directory
+    await fs.mkdir("./nested");
+    await fs.writeFile("./nested/mock-module-two.js", `
+		export function hello() {
+			return "world";
+		}
+		`);
+    const _import = createImport({
+        readFile: fs.readFile,
+        fetch,
+    });
+    it("should import a module from a local path", async () => {
+        const module = await _import("./mock-module.js");
+        expect(module.hello()).toBe("hello");
+    });
+    it("should import a module from a nested local path", async () => {
+        const module = await _import("./nested/mock-module-two.js");
+        expect(module.hello()).toBe("world");
+    });
+    it("should import an ES module from a url", async () => {
+        const module = await _import("https://cdn.jsdelivr.net/npm/normalize-url@7.2.0/index.js");
+        const normalizeUrl = module.default;
+        expect(normalizeUrl("inlang.com")).toBe("http://inlang.com");
+    });
+    it("should throw if a module is loaded that is not an ES module", async () => {
+        try {
+            await _import("https://cdn.jsdelivr.net/npm/lodash@4.17.21");
+            throw "function did not throw";
+        }
+        catch {
+            expect(true).toBe(true);
+        }
+    });
+});

package/dist/resolve-modules/index.d.ts

@@ -0,0 +1,3 @@
+export { resolveModules } from "./resolveModules.js";
+export { type ImportFunction, createImport } from "./import.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/resolve-modules/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/resolve-modules/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAA;AACpD,OAAO,EAAE,KAAK,cAAc,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA"}

package/dist/resolve-modules/index.js

@@ -0,0 +1,2 @@
+export { resolveModules } from "./resolveModules.js";
+export { createImport } from "./import.js";

package/dist/resolve-modules/message-lint-rules/errors.d.ts

@@ -0,0 +1,8 @@
+export declare class MessageLintRuleIsInvalidError extends Error {
+    readonly module: string;
+    constructor(message: string, options: {
+        module: string;
+        cause?: Error;
+    });
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/resolve-modules/message-lint-rules/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../src/resolve-modules/message-lint-rules/errors.ts"],"names":[],"mappings":"AAAA,qBAAa,6BAA8B,SAAQ,KAAK;IACvD,SAAgB,MAAM,EAAE,MAAM,CAAA;gBAElB,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,KAAK,CAAA;KAAE;CAKvE"}

package/dist/resolve-modules/message-lint-rules/errors.js

@@ -0,0 +1,8 @@
+export class MessageLintRuleIsInvalidError extends Error {
+    module;
+    constructor(message, options) {
+        super(message);
+        this.module = options.module;
+        this.name = "MessageLintRuleIsInvalidError";
+    }
+}

package/dist/resolve-modules/message-lint-rules/resolveMessageLintRules.d.ts

@@ -0,0 +1,9 @@
+import { MessageLintRule } from "@inlang/message-lint-rule";
+import { MessageLintRuleIsInvalidError } from "./errors.js";
+export declare const resolveMessageLintRules: (args: {
+    messageLintRules: Array<MessageLintRule>;
+}) => {
+    data: MessageLintRule[];
+    errors: MessageLintRuleIsInvalidError[];
+};
+//# sourceMappingURL=resolveMessageLintRules.d.ts.map

package/dist/resolve-modules/message-lint-rules/resolveMessageLintRules.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolveMessageLintRules.d.ts","sourceRoot":"","sources":["../../../src/resolve-modules/message-lint-rules/resolveMessageLintRules.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAA;AAC3D,OAAO,EAAE,6BAA6B,EAAE,MAAM,aAAa,CAAA;AAE3D,eAAO,MAAM,uBAAuB,SAAU;IAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC,CAAA;CAAE;;;CAmBzF,CAAA"}

package/dist/resolve-modules/message-lint-rules/resolveMessageLintRules.js

@@ -0,0 +1,21 @@
+import { Value } from "@sinclair/typebox/value";
+import { MessageLintRule } from "@inlang/message-lint-rule";
+import { MessageLintRuleIsInvalidError } from "./errors.js";
+export const resolveMessageLintRules = (args) => {
+    const result = {
+        data: [],
+        errors: [],
+    };
+    for (const rule of args.messageLintRules) {
+        if (Value.Check(MessageLintRule, rule) === false) {
+            result.errors.push(new MessageLintRuleIsInvalidError(`Couldn't parse lint rule "${rule.meta.id}"`, {
+                module: "not implemented",
+            }));
+            continue;
+        }
+        else {
+            result.data.push(rule);
+        }
+    }
+    return result;
+};

package/dist/resolve-modules/plugins/errors.d.ts

@@ -0,0 +1,28 @@
+import type { Plugin } from "@inlang/plugin";
+type PluginErrorOptions = {
+    plugin: Plugin["meta"]["id"];
+} & Partial<Error>;
+declare class PluginError extends Error {
+    readonly plugin: string;
+    constructor(message: string, options: PluginErrorOptions);
+}
+export declare class PluginHasInvalidIdError extends PluginError {
+    constructor(message: string, options: PluginErrorOptions);
+}
+export declare class PluginUsesReservedNamespaceError extends PluginError {
+    constructor(message: string, options: PluginErrorOptions);
+}
+export declare class PluginHasInvalidSchemaError extends PluginError {
+    constructor(message: string, options: PluginErrorOptions);
+}
+export declare class PluginLoadMessagesFunctionAlreadyDefinedError extends PluginError {
+    constructor(message: string, options: PluginErrorOptions);
+}
+export declare class PluginSaveMessagesFunctionAlreadyDefinedError extends PluginError {
+    constructor(message: string, options: PluginErrorOptions);
+}
+export declare class PluginReturnedInvalidCustomApiError extends PluginError {
+    constructor(message: string, options: PluginErrorOptions);
+}
+export {};
+//# sourceMappingURL=errors.d.ts.map

package/dist/resolve-modules/plugins/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../src/resolve-modules/plugins/errors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAA;AAE5C,KAAK,kBAAkB,GAAG;IACzB,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,CAAA;CAC5B,GAAG,OAAO,CAAC,KAAK,CAAC,CAAA;AAElB,cAAM,WAAY,SAAQ,KAAK;IAC9B,SAAgB,MAAM,EAAE,MAAM,CAAA;gBAElB,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,kBAAkB;CAKxD;AAED,qBAAa,uBAAwB,SAAQ,WAAW;gBAC3C,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,kBAAkB;CAIxD;AAED,qBAAa,gCAAiC,SAAQ,WAAW;gBACpD,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,kBAAkB;CAIxD;AAED,qBAAa,2BAA4B,SAAQ,WAAW;gBAC/C,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,kBAAkB;CAIxD;AAED,qBAAa,6CAA8C,SAAQ,WAAW;gBACjE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,kBAAkB;CAIxD;AAED,qBAAa,6CAA8C,SAAQ,WAAW;gBACjE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,kBAAkB;CAIxD;AAED,qBAAa,mCAAoC,SAAQ,WAAW;gBACvD,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,kBAAkB;CAIxD"}