@typeberry/lib 0.5.1-aff8b4f → 0.5.1-eb84786

package/packages/core/json-parser/descriptors.js

@@ -0,0 +1,88 @@
+import { parseFromJson } from "./parse.js";
+export var json;
+(function (json) {
+    /** Parse a JSON string into the expected type. */
+    function fromString(parser) {
+        return ["string", parser];
+    }
+    json.fromString = fromString;
+    /** Parse a JSON number into the expected type. */
+    function fromNumber(parser) {
+        return ["number", parser];
+    }
+    json.fromNumber = fromNumber;
+    /** Parse a JSON bigint or number into the expected type. */
+    function fromBigInt(parser) {
+        return [
+            "object",
+            (x) => {
+                if (typeof x === "number" || typeof x === "bigint") {
+                    return parser(BigInt(x));
+                }
+                throw new Error(`Expected number or bigint got: ${typeof x} (${x})`);
+            },
+        ];
+    }
+    json.fromBigInt = fromBigInt;
+    /** Cast the JSON number into the expected type. */
+    function castNumber() {
+        return fromNumber((v) => v);
+    }
+    json.castNumber = castNumber;
+    /** Parse any (`unknown`) JSON value into the expected type. */
+    function fromAny(parser) {
+        return ["object", parser];
+    }
+    json.fromAny = fromAny;
+    /** Handle a potentially optional value. Can be either `undefined` or `null` in JSON. */
+    function optional(from) {
+        return ["optional", from];
+    }
+    json.optional = optional;
+    /** Handle a potentially optional value that can be `null` in JSON. */
+    function nullable(from) {
+        return ["optional", from];
+    }
+    json.nullable = nullable;
+    /** Expect an array of given type in JSON. */
+    function array(from) {
+        return ["array", from];
+    }
+    json.array = array;
+    /** Parse an object record with the given type. */
+    function record(from) {
+        return fromAny((inJson, context) => {
+            if (typeof inJson !== "object" || inJson === null) {
+                throw new Error("Expected object record for parsing");
+            }
+            const result = {};
+            for (const [key, value] of Object.entries(inJson)) {
+                result[key] = parseFromJson(value, from, `${context}.${key}`);
+            }
+            return result;
+        });
+    }
+    json.record = record;
+    /** Parse a map with the given type. */
+    function map(K, V) {
+        return fromAny((inJson, context) => {
+            if (typeof inJson !== "object" || inJson === null) {
+                throw new Error("Expected map for parsing");
+            }
+            const result = new Map();
+            for (const [key, value] of Object.entries(inJson)) {
+                result.set(parseFromJson(key, K, `${context}.key`), parseFromJson(value, V, `${context}.value`));
+            }
+            return result;
+        });
+    }
+    json.map = map;
+    /** Parse an object and create a class instance of given type using `builder` function. */
+    function object(from, builder) {
+        return fromAny((inJson, context) => {
+            const parsed = parseFromJson(inJson, from, context);
+            return builder(parsed);
+        });
+    }
+    json.object = object;
+})(json || (json = {}));

package/packages/core/json-parser/index.d.ts

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

package/packages/core/json-parser/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../packages/core/json-parser/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC;AACjC,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC"}

package/packages/core/json-parser/index.js

@@ -0,0 +1,3 @@
+export * from "./descriptors.js";
+export * from "./parse.js";
+export * from "./types.js";

package/packages/core/json-parser/index.test.d.ts

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

package/packages/core/json-parser/index.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.test.d.ts","sourceRoot":"","sources":["../../../../../packages/core/json-parser/index.test.ts"],"names":[],"mappings":""}

package/packages/core/json-parser/index.test.js

@@ -0,0 +1,138 @@
+import assert from "node:assert";
+import { test } from "node:test";
+import { json, parseFromJson } from "./index.js";
+test("JSON parser", async (t) => {
+    await t.test("parse simple class", () => {
+        const j = `{"k": 5, "v": true }`;
+        class TestClass {
+            static fromJson = {
+                k: "number",
+                v: "boolean",
+            };
+            k = 0;
+            v = false;
+        }
+        const result = parseFromJson(JSON.parse(j), TestClass.fromJson);
+        assert.strictEqual(result.k, 5);
+        assert.strictEqual(result.v, true);
+    });
+    await t.test("parse nested object", () => {
+        const json = `{"k": "xyz", "nested": { "k": 5, "v": true }}`;
+        class NestedClass {
+            static fromJson = {
+                k: "number",
+                v: "boolean",
+            };
+            k = 0;
+            v = false;
+        }
+        class TestClass {
+            static fromJson = {
+                k: "string",
+                nested: NestedClass.fromJson,
+            };
+            k = "";
+            nested = new NestedClass();
+        }
+        const result = parseFromJson(JSON.parse(json), TestClass.fromJson);
+        assert.strictEqual(result.k, "xyz");
+        assert.deepStrictEqual(result.nested, {
+            k: 5,
+            v: true,
+        });
+    });
+    await t.test("parse & process", () => {
+        const j = `{"k": "0x123", "v": true }`;
+        class TestClass {
+            static fromJson = {
+                k: json.fromString((v) => Number(v)),
+                v: "boolean",
+            };
+            k = 0;
+            v = false;
+        }
+        const result = parseFromJson(JSON.parse(j), TestClass.fromJson);
+        assert.strictEqual(result.k, 0x123);
+        assert.strictEqual(result.v, true);
+    });
+    await t.test("arrays", () => {
+        const j = `{"k": ["a", "b", "c"]}`;
+        class TestClass {
+            static fromJson = {
+                k: json.array("string"),
+            };
+            k;
+        }
+        const result = parseFromJson(JSON.parse(j), TestClass.fromJson);
+        assert.deepStrictEqual(result.k, ["a", "b", "c"]);
+    });
+    await t.test("keys mismatch", () => {
+        const json = `{"x": 5, "v": true }`;
+        class TestClass {
+            static fromJson = {
+                k: "number",
+                v: "boolean",
+            };
+            k = 0;
+            v = false;
+        }
+        try {
+            parseFromJson(JSON.parse(json), TestClass.fromJson);
+            assert.fail("Expected error to be thrown");
+        }
+        catch (e) {
+            assert.strictEqual(`${e}`, `Error: [<root>] Unexpected or missing keys: <missing>,"k" | "x",<missing>
+          Data: x,v
+          Schema: k,v`);
+        }
+    });
+    await t.test("type mismatch", () => {
+        const json = `{"k": "sdf", "v": true }`;
+        class TestClass {
+            static fromJson = {
+                k: "number",
+                v: "boolean",
+            };
+            k = 0;
+            v = false;
+        }
+        try {
+            parseFromJson(JSON.parse(json), TestClass.fromJson);
+            assert.fail("Expected error to be thrown");
+        }
+        catch (e) {
+            assert.strictEqual(`${e}`, "Error: [<root>.k] Expected number but got string");
+        }
+    });
+    await t.test("correct instanceof", () => {
+        const j = `{"k": "sdf", "v": true }`;
+        class TestClass {
+            static fromJson = json.object({
+                k: "string",
+                v: "boolean",
+            }, (x) => Object.assign(new TestClass(), x));
+            k = "";
+            v = false;
+        }
+        const result = parseFromJson(JSON.parse(j), TestClass.fromJson);
+        const expected = new TestClass();
+        expected.k = "sdf";
+        expected.v = true;
+        assert.deepStrictEqual(result, expected);
+        assert.strictEqual(result instanceof TestClass, true);
+    });
+    await t.test("optionals", () => {
+        const j = `{"v": true }`;
+        class TestClass {
+            static fromJson = {
+                k: json.optional("number"),
+                v: json.optional("boolean"),
+            };
+            k;
+            v;
+        }
+        const result = parseFromJson(JSON.parse(j), TestClass.fromJson);
+        assert.strictEqual(result.k, undefined);
+        assert.strictEqual(result.v, true);
+    });
+});

package/packages/core/json-parser/parse.d.ts

@@ -0,0 +1,4 @@
+import type { FromJson } from "./types.js";
+/** Given already parsed JSON, parse & validate it further to match the expected `jsonDescription` type. */
+export declare function parseFromJson<T>(jsonType: unknown, jsonDescription: FromJson<T>, context?: string): T;
+//# sourceMappingURL=parse.d.ts.map

package/packages/core/json-parser/parse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse.d.ts","sourceRoot":"","sources":["../../../../../packages/core/json-parser/parse.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAU,MAAM,YAAY,CAAC;AAInD,2GAA2G;AAC3G,wBAAgB,aAAa,CAAC,CAAC,EAAE,QAAQ,EAAE,OAAO,EAAE,eAAe,EAAE,QAAQ,CAAC,CAAC,CAAC,EAAE,OAAO,SAAW,GAAG,CAAC,CAsIvG"}

package/packages/core/json-parser/parse.js

@@ -0,0 +1,143 @@
+const NO_KEY = Symbol("no key");
+/** Given already parsed JSON, parse & validate it further to match the expected `jsonDescription` type. */
+export function parseFromJson(jsonType, jsonDescription, context = "<root>") {
+    const t = typeof jsonType;
+    if (jsonDescription === "string") {
+        if (t === "string") {
+            return jsonType;
+        }
+        throw new Error(`[${context}] Expected ${jsonDescription} but got ${t}`);
+    }
+    if (jsonDescription === "number") {
+        if (t === "number") {
+            return jsonType;
+        }
+        throw new Error(`[${context}] Expected ${jsonDescription} but got ${t}`);
+    }
+    if (jsonDescription === "boolean") {
+        if (t === "boolean") {
+            return jsonType;
+        }
+        throw new Error(`[${context}] Expected ${jsonDescription} but got ${t}`);
+    }
+    if (Array.isArray(jsonDescription)) {
+        const type = jsonDescription[0];
+        // an array type
+        if (type === "array") {
+            const expectedType = jsonDescription[1];
+            if (typeof expectedType === "function") {
+                return expectedType(jsonType, context);
+            }
+            if (!Array.isArray(jsonType)) {
+                throw new Error(`[${context}] Expected array, got ${jsonType}`);
+            }
+            const arr = jsonType;
+            const result = [];
+            for (const [k, v] of arr.entries()) {
+                result[k] = parseFromJson(v, expectedType, `${context}.${k}`);
+            }
+            return result;
+        }
+        // optional type
+        if (type === "optional") {
+            if (jsonType === undefined || jsonType === null) {
+                return jsonType;
+            }
+            const expectedType = jsonDescription[1];
+            return parseFromJson(jsonType, expectedType, context);
+        }
+        // a manual parser for nested object
+        if (type === "object") {
+            const parser = jsonDescription[1];
+            const obj = jsonType;
+            return parseOrThrow(parser, obj, context);
+        }
+        // An expected in-json type and the parser to the destination type.
+        if (type === "string") {
+            const parser = jsonDescription[1];
+            const value = parseFromJson(jsonType, type, context);
+            return parseOrThrow(parser, value, context);
+        }
+        if (type === "number") {
+            const type = jsonDescription[0];
+            const parser = jsonDescription[1];
+            const value = parseFromJson(jsonType, type, context);
+            return parseOrThrow(parser, value, context);
+        }
+        throw new Error(`[${context}] Invalid parser type: ${type}`);
+    }
+    if (t !== "object") {
+        throw new Error(`[${context}] Expected complex type but got ${t}`);
+    }
+    if (typeof jsonDescription !== "object") {
+        throw new Error(`[${context}] Unhandled type ${jsonDescription}`);
+    }
+    if (jsonType === null) {
+        throw new Error(`[${context}] Unexpected 'null'`);
+    }
+    const result = {};
+    const obj = jsonType;
+    const c = jsonDescription;
+    // add all keys so that they are in the same order.
+    for (const key of Object.keys(obj)) {
+        result[key] = undefined;
+    }
+    // now parse the ones that we need (some might be optional, but that's fine).
+    for (const key of Object.keys(jsonDescription)) {
+        // we intentionally skip missing keys, to have them detected
+        // during key diffing. But for optional keys we put NO_KEY value
+        // to make sure key diffing works fine.
+        if (key in obj) {
+            const v = obj[key];
+            result[key] = parseFromJson(v, c[key], `${context}.${key}`);
+        }
+        else if (Array.isArray(c[key]) && c[key][0] === "optional") {
+            result[key] = NO_KEY;
+        }
+    }
+    // compute the key difference
+    const keysDifference = diffKeys(result, jsonDescription);
+    if (keysDifference.length > 0) {
+        const e = new Error(`[${context}] Unexpected or missing keys: ${keysDifference.join(" | ")}
+          Data: ${Object.keys(result)}
+          Schema: ${Object.keys(jsonDescription)}`);
+        throw e;
+    }
+    // clean up keys with no value
+    for (const key of Object.keys(result)) {
+        if (result[key] === NO_KEY) {
+            delete result[key];
+        }
+    }
+    return result;
+}
+function diffKeys(obj1, obj2) {
+    const keys1 = Object.keys(obj1);
+    const keys2 = Object.keys(obj2);
+    keys1.sort();
+    keys2.sort();
+    const keysCounter = {};
+    const max = Math.max(keys2.length, keys2.length);
+    const KEY1_SET = 1;
+    const KEY2_SET = 2;
+    for (let i = 0; i < max; i++) {
+        keysCounter[keys1[i]] = (keysCounter[keys1[i]] || 0) + KEY1_SET;
+        keysCounter[keys2[i]] = (keysCounter[keys2[i]] || 0) + KEY2_SET;
+    }
+    const diff = [];
+    const id = (v) => (v !== undefined ? `"${v}"` : "<missing>");
+    for (const [k, v] of Object.entries(keysCounter)) {
+        if (v !== KEY1_SET + KEY2_SET && k !== "undefined") {
+            diff.push(v === KEY1_SET ? [id(k), id(undefined)] : [id(undefined), id(k)]);
+        }
+    }
+    return diff;
+}
+function parseOrThrow(parser, value, context) {
+    try {
+        return parser(value, context);
+    }
+    catch (e) {
+        throw new Error(`[${context}] Error while parsing the value: ${e}`);
+    }
+}

package/packages/core/json-parser/types.d.ts

@@ -0,0 +1,17 @@
+/** A type that can be read from a JSON-parsed object. */
+export type FromJson<T> = T extends (infer U)[] | readonly (infer U)[] ? ["array", FromJson<U> | Parser<unknown, U[]>] : FromJsonWithParser<string, T> | FromJsonWithParser<number, T> | FromJsonWithParser<unknown, T> | FromJsonPrimitive<T> | FromJsonOptional<T>;
+/** Parsing a JSON primitive value. */
+export type FromJsonPrimitive<T> = T extends string ? "string" : T extends number ? "number" : T extends boolean ? "boolean" : T extends object ? ObjectFromJson<T> : T extends unknown ? "object" : never;
+/** Conversion from some JSON type into the expected type. */
+export type Parser<TFrom, TInto> = (inJson: TFrom, context?: string) => TInto;
+/** Parsing a JSON value with given convesion. */
+export type FromJsonWithParser<TFrom, TInto> = [FromJsonPrimitive<TFrom>, Parser<TFrom, TInto>];
+/** A potentially optional JSON parameter (key/value undefined). */
+export type FromJsonOptional<TInto> = ["optional", FromJson<TInto>];
+/** A composite JSON object. */
+export type ObjectFromJson<T> = {
+    [K in keyof T]: FromJson<T[K]>;
+};
+/** Builder function that converts an object parsed from JSON into some expected type of object. */
+export type Builder<TFrom, TInto> = (x: TFrom) => TInto;
+//# sourceMappingURL=types.d.ts.map

package/packages/core/json-parser/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../packages/core/json-parser/types.ts"],"names":[],"mappings":"AAAA,yDAAyD;AAEzD,MAAM,MAAM,QAAQ,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,EAAE,GAAG,SAAS,CAAC,MAAM,CAAC,CAAC,EAAE,GAClE,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,OAAO,EAAE,CAAC,EAAE,CAAC,CAAC,GAEzC,kBAAkB,CAAC,MAAM,EAAE,CAAC,CAAC,GAE7B,kBAAkB,CAAC,MAAM,EAAE,CAAC,CAAC,GAE7B,kBAAkB,CAAC,OAAO,EAAE,CAAC,CAAC,GAC9B,iBAAiB,CAAC,CAAC,CAAC,GACpB,gBAAgB,CAAC,CAAC,CAAC,CAAC;AAE5B,sCAAsC;AACtC,MAAM,MAAM,iBAAiB,CAAC,CAAC,IAAI,CAAC,SAAS,MAAM,GAC/C,QAAQ,GACR,CAAC,SAAS,MAAM,GACd,QAAQ,GACR,CAAC,SAAS,OAAO,GACf,SAAS,GACT,CAAC,SAAS,MAAM,GACd,cAAc,CAAC,CAAC,CAAC,GACjB,CAAC,SAAS,OAAO,GACf,QAAQ,GACR,KAAK,CAAC;AAElB,6DAA6D;AAC7D,MAAM,MAAM,MAAM,CAAC,KAAK,EAAE,KAAK,IAAI,CAAC,MAAM,EAAE,KAAK,EAAE,OAAO,CAAC,EAAE,MAAM,KAAK,KAAK,CAAC;AAE9E,iDAAiD;AACjD,MAAM,MAAM,kBAAkB,CAAC,KAAK,EAAE,KAAK,IAAI,CAAC,iBAAiB,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC;AAEhG,mEAAmE;AACnE,MAAM,MAAM,gBAAgB,CAAC,KAAK,IAAI,CAAC,UAAU,EAAE,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC;AAEpE,+BAA+B;AAC/B,MAAM,MAAM,cAAc,CAAC,CAAC,IAAI;KAC7B,CAAC,IAAI,MAAM,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;CAC/B,CAAC;AAEF,mGAAmG;AACnG,MAAM,MAAM,OAAO,CAAC,KAAK,EAAE,KAAK,IAAI,CAAC,CAAC,EAAE,KAAK,KAAK,KAAK,CAAC"}

package/packages/core/json-parser/types.js

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

package/packages/core/listener/index.d.ts

@@ -0,0 +1,13 @@
+/** A typed version of event emitter. */
+export declare class Listener<T> {
+    private readonly emitter;
+    emit(data: T): void;
+    on(listener: (d: T) => void): this;
+    off(listener: (d: T) => void): this;
+    once(listener: (d: T) => void): this;
+    onceDone(listener: () => void): this;
+    markDone(): void;
+    /** Return a callback that will emit events. */
+    callbackHandler(): (req: T) => Promise<void>;
+}
+//# sourceMappingURL=index.d.ts.map

package/packages/core/listener/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../packages/core/listener/index.ts"],"names":[],"mappings":"AAKA,wCAAwC;AACxC,qBAAa,QAAQ,CAAC,CAAC;IACrB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAsB;IAE9C,IAAI,CAAC,IAAI,EAAE,CAAC;IAIZ,EAAE,CAAC,QAAQ,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,IAAI;IAK3B,GAAG,CAAC,QAAQ,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,IAAI;IAK5B,IAAI,CAAC,QAAQ,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,IAAI;IAK7B,QAAQ,CAAC,QAAQ,EAAE,MAAM,IAAI;IAK7B,QAAQ;IAMR,+CAA+C;IAC/C,eAAe,IAAI,CAAC,GAAG,EAAE,CAAC,KAAK,OAAO,CAAC,IAAI,CAAC;CAQ7C"}

package/packages/core/listener/index.js

@@ -0,0 +1,40 @@
+import { EventEmitter } from "node:events";
+const EVENT = Symbol();
+const EVENT_DONE = Symbol();
+/** A typed version of event emitter. */
+export class Listener {
+    emitter = new EventEmitter();
+    emit(data) {
+        this.emitter.emit(EVENT, data);
+    }
+    on(listener) {
+        this.emitter.on(EVENT, listener);
+        return this;
+    }
+    off(listener) {
+        this.emitter.off(EVENT, listener);
+        return this;
+    }
+    once(listener) {
+        this.emitter.once(EVENT, listener);
+        return this;
+    }
+    onceDone(listener) {
+        this.emitter.once(EVENT_DONE, listener);
+        return this;
+    }
+    markDone() {
+        this.emitter.emit(EVENT_DONE);
+        this.emitter.removeAllListeners(EVENT);
+        this.emitter.removeAllListeners(EVENT_DONE);
+    }
+    /** Return a callback that will emit events. */
+    callbackHandler() {
+        return async (req) => {
+            // to avoid deadlocks and since we don't care about that signal,
+            // we simply return the response immediately and process the emitting
+            // later
+            setImmediate(() => this.emit(req));
+        };
+    }
+}

package/packages/core/logger/console.d.ts

@@ -0,0 +1,22 @@
+import { Level, type Options } from "./options.js";
+import type { Transport } from "./transport.js";
+/** An optimized logger that ignores `TRACE`, `DEBUG` and `LOG` messages.
+ *
+ * Use the `create` method to instantiate the right instance of a more specialized logger.
+ */
+export declare class ConsoleTransport implements Transport {
+    protected options: Options;
+    /**
+     * Creates a new optimized logger which ignores messages that are below the
+     * `minimalLevel`.
+     */
+    static create(minimalLevel: Level, options: Options): ConsoleTransport;
+    protected constructor(options: Options);
+    insane(_levelAndName: readonly [Level, string], _strings: TemplateStringsArray, _data: unknown[]): void;
+    trace(_levelAndName: readonly [Level, string], _strings: TemplateStringsArray, _data: unknown[]): void;
+    log(_levelAndName: readonly [Level, string], _strings: TemplateStringsArray, _data: unknown[]): void;
+    info(_levelAndName: readonly [Level, string], _strings: TemplateStringsArray, _data: unknown[]): void;
+    warn(levelAndName: readonly [Level, string], strings: TemplateStringsArray, data: unknown[]): void;
+    error(levelAndName: readonly [Level, string], strings: TemplateStringsArray, data: unknown[]): void;
+}
+//# sourceMappingURL=console.d.ts.map

package/packages/core/logger/console.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"console.d.ts","sourceRoot":"","sources":["../../../../../packages/core/logger/console.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,EAAE,KAAK,OAAO,EAAE,MAAM,cAAc,CAAC;AACnD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAmBhD;;;GAGG;AACH,qBAAa,gBAAiB,YAAW,SAAS;IA2B1B,SAAS,CAAC,OAAO,EAAE,OAAO;IA1BhD;;;OAGG;IACH,MAAM,CAAC,MAAM,CAAC,YAAY,EAAE,KAAK,EAAE,OAAO,EAAE,OAAO;IAsBnD,SAAS,aAAuB,OAAO,EAAE,OAAO;IAEhD,MAAM,CAAC,aAAa,EAAE,SAAS,CAAC,KAAK,EAAE,MAAM,CAAC,EAAE,QAAQ,EAAE,oBAAoB,EAAE,KAAK,EAAE,OAAO,EAAE;IAIhG,KAAK,CAAC,aAAa,EAAE,SAAS,CAAC,KAAK,EAAE,MAAM,CAAC,EAAE,QAAQ,EAAE,oBAAoB,EAAE,KAAK,EAAE,OAAO,EAAE;IAI/F,GAAG,CAAC,aAAa,EAAE,SAAS,CAAC,KAAK,EAAE,MAAM,CAAC,EAAE,QAAQ,EAAE,oBAAoB,EAAE,KAAK,EAAE,OAAO,EAAE;IAI7F,IAAI,CAAC,aAAa,EAAE,SAAS,CAAC,KAAK,EAAE,MAAM,CAAC,EAAE,QAAQ,EAAE,oBAAoB,EAAE,KAAK,EAAE,OAAO,EAAE;IAI9F,IAAI,CAAC,YAAY,EAAE,SAAS,CAAC,KAAK,EAAE,MAAM,CAAC,EAAE,OAAO,EAAE,oBAAoB,EAAE,IAAI,EAAE,OAAO,EAAE;IAI3F,KAAK,CAAC,YAAY,EAAE,SAAS,CAAC,KAAK,EAAE,MAAM,CAAC,EAAE,OAAO,EAAE,oBAAoB,EAAE,IAAI,EAAE,OAAO,EAAE;CAG7F"}

package/packages/core/logger/console.js

@@ -0,0 +1,136 @@
+// biome-ignore-all lint/suspicious/noConsole: logger
+import { Level } from "./options.js";
+function print(level, levelAndName, strings, data) {
+    if (level < levelAndName[0]) {
+        return;
+    }
+    const lvlText = Level[level].padEnd(5);
+    const val = strings.map((v, idx) => `${v}${idx < data.length ? data[idx] : ""}`);
+    const msg = `${lvlText} [${levelAndName[1].padStart(8, " ")}] ${val.join("")}`;
+    if (level === Level.WARN) {
+        console.warn(msg);
+    }
+    else if (level === Level.ERROR) {
+        console.error(msg);
+    }
+    else {
+        console.info(msg);
+    }
+}
+/** An optimized logger that ignores `TRACE`, `DEBUG` and `LOG` messages.
+ *
+ * Use the `create` method to instantiate the right instance of a more specialized logger.
+ */
+export class ConsoleTransport {
+    options;
+    /**
+     * Creates a new optimized logger which ignores messages that are below the
+     * `minimalLevel`.
+     */
+    static create(minimalLevel, options) {
+        // optimised transports if we don't care about trace/log levels
+        if (minimalLevel === Level.INSANE) {
+            return new InsaneConsoleLogger(options);
+        }
+        // optimised transports if we don't care about trace/log levels
+        if (minimalLevel === Level.TRACE) {
+            return new TraceConsoleTransport(options);
+        }
+        if (minimalLevel === Level.LOG) {
+            return new LogConsoleTransport(options);
+        }
+        if (minimalLevel === Level.INFO) {
+            return new InfoConsoleTransport(options);
+        }
+        return new ConsoleTransport(options);
+    }
+    constructor(options) {
+        this.options = options;
+    }
+    insane(_levelAndName, _strings, _data) {
+        /* no-op */
+    }
+    trace(_levelAndName, _strings, _data) {
+        /* no-op */
+    }
+    log(_levelAndName, _strings, _data) {
+        /* no-op */
+    }
+    info(_levelAndName, _strings, _data) {
+        /* no-op */
+    }
+    warn(levelAndName, strings, data) {
+        print(Level.WARN, levelAndName, strings, data);
+    }
+    error(levelAndName, strings, data) {
+        print(Level.ERROR, levelAndName, strings, data);
+    }
+}
+/**
+ * Insane version of console logger - supports insane level.
+ */
+class InsaneConsoleLogger extends ConsoleTransport {
+    insane(levelAndName, strings, data) {
+        print(Level.INSANE, levelAndName, strings, data);
+    }
+    trace(levelAndName, strings, data) {
+        print(Level.TRACE, levelAndName, strings, data);
+    }
+    log(levelAndName, strings, data) {
+        print(Level.LOG, levelAndName, strings, data);
+    }
+    info(levelAndName, strings, data) {
+        print(Level.INFO, levelAndName, strings, data);
+    }
+}
+/**
+ * A basic version of console logger - printing everything.
+ */
+class TraceConsoleTransport extends ConsoleTransport {
+    insane(_levelAndName, _strings, _data) {
+        /* no-op */
+    }
+    trace(levelAndName, strings, data) {
+        print(Level.TRACE, levelAndName, strings, data);
+    }
+    log(levelAndName, strings, data) {
+        print(Level.LOG, levelAndName, strings, data);
+    }
+    info(levelAndName, strings, data) {
+        print(Level.INFO, levelAndName, strings, data);
+    }
+}
+/**
+ * An optimized version of the logger - completely ignores `TRACE` level calls.
+ */
+class LogConsoleTransport extends ConsoleTransport {
+    insane(_levelAndName, _strings, _data) {
+        /* no-op */
+    }
+    trace(_levelAndName, _strings, _data) {
+        /* no-op */
+    }
+    log(levelAndName, strings, data) {
+        print(Level.LOG, levelAndName, strings, data);
+    }
+    info(levelAndName, strings, data) {
+        print(Level.INFO, levelAndName, strings, data);
+    }
+}
+/**
+ * An optimized version of the logger - completely ignores `TRACE` & `DEBUG` level calls.
+ */
+class InfoConsoleTransport extends ConsoleTransport {
+    insane(_levelAndName, _strings, _data) {
+        /* no-op */
+    }
+    trace(_levelAndName, _strings, _data) {
+        /* no-op */
+    }
+    log(_levelAndName, _strings, _data) {
+        /* no-op */
+    }
+    info(levelAndName, strings, data) {
+        print(Level.INFO, levelAndName, strings, data);
+    }
+}

package/packages/core/logger/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./console.js";
+export * from "./logger.js";
+export * from "./options.js";
+export * from "./transport.js";
+//# sourceMappingURL=index.d.ts.map

package/packages/core/logger/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../packages/core/logger/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,cAAc,aAAa,CAAC;AAC5B,cAAc,cAAc,CAAC;AAC7B,cAAc,gBAAgB,CAAC"}

package/packages/core/logger/index.js

@@ -0,0 +1,4 @@
+export * from "./console.js";
+export * from "./logger.js";
+export * from "./options.js";
+export * from "./transport.js";