@typeberry/lib 0.5.1-a4d7c93 → 0.5.1-eb84786

package/packages/core/utils/compatibility.d.ts

@@ -0,0 +1,31 @@
+export declare enum GpVersion {
+    V0_7_0 = "0.7.0",
+    V0_7_1 = "0.7.1",
+    V0_7_2 = "0.7.2"
+}
+export declare enum TestSuite {
+    W3F_DAVXY = "w3f-davxy"
+}
+export declare const DEFAULT_SUITE = TestSuite.W3F_DAVXY;
+export declare const DEFAULT_VERSION = GpVersion.V0_7_2;
+export declare let CURRENT_VERSION: GpVersion;
+export declare let CURRENT_SUITE: TestSuite;
+export declare class Compatibility {
+    static override(version?: GpVersion): void;
+    static overrideSuite(suite: TestSuite): void;
+    static is(...version: GpVersion[]): boolean;
+    static isSuite(suite: TestSuite, version?: GpVersion): boolean;
+    static isGreaterOrEqual(version: GpVersion): boolean;
+    /**
+     * Allows selecting different values for different Gray Paper versions from one record.
+     *
+     * fallback The default value to return if no value is found for the current.
+     * versions A record mapping versions to values, checking if the version is greater or equal to the current version.
+     * @returns The value for the current version, or the default value.
+     */
+    static selectIfGreaterOrEqual<T>({ fallback, versions, }: {
+        fallback: T;
+        versions: Partial<Record<GpVersion, T>>;
+    }): T;
+}
+//# sourceMappingURL=compatibility.d.ts.map

package/packages/core/utils/compatibility.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compatibility.d.ts","sourceRoot":"","sources":["../../../../../packages/core/utils/compatibility.ts"],"names":[],"mappings":"AAEA,oBAAY,SAAS;IACnB,MAAM,UAAU;IAChB,MAAM,UAAU;IAChB,MAAM,UAAU;CACjB;AAED,oBAAY,SAAS;IACnB,SAAS,cAAc;CACxB;AAKD,eAAO,MAAM,aAAa,sBAAsB,CAAC;AACjD,eAAO,MAAM,eAAe,mBAAmB,CAAC;AAEhD,eAAO,IAAI,eAAe,WAAyD,CAAC;AACpF,eAAO,IAAI,aAAa,WAAqD,CAAC;AA8B9E,qBAAa,aAAa;IACxB,MAAM,CAAC,QAAQ,CAAC,OAAO,CAAC,EAAE,SAAS;IAInC,MAAM,CAAC,aAAa,CAAC,KAAK,EAAE,SAAS;IAIrC,MAAM,CAAC,EAAE,CAAC,GAAG,OAAO,EAAE,SAAS,EAAE;IAOjC,MAAM,CAAC,OAAO,CAAC,KAAK,EAAE,SAAS,EAAE,OAAO,CAAC,EAAE,SAAS;IASpD,MAAM,CAAC,gBAAgB,CAAC,OAAO,EAAE,SAAS;IAQ1C;;;;;;OAMG;IACH,MAAM,CAAC,sBAAsB,CAAC,CAAC,EAAE,EAC/B,QAAQ,EACR,QAAQ,GACT,EAAE;QACD,QAAQ,EAAE,CAAC,CAAC;QACZ,QAAQ,EAAE,OAAO,CAAC,MAAM,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC,CAAC;KACzC,GAAG,CAAC;CASN"}

package/packages/core/utils/compatibility.js

@@ -0,0 +1,83 @@
+import { env } from "./env.js";
+export var GpVersion;
+(function (GpVersion) {
+    GpVersion["V0_7_0"] = "0.7.0";
+    GpVersion["V0_7_1"] = "0.7.1";
+    GpVersion["V0_7_2"] = "0.7.2";
+})(GpVersion || (GpVersion = {}));
+export var TestSuite;
+(function (TestSuite) {
+    TestSuite["W3F_DAVXY"] = "w3f-davxy";
+})(TestSuite || (TestSuite = {}));
+// NOTE: Also acts as a supported versions
+const ALL_VERSIONS_IN_ORDER = [GpVersion.V0_7_0, GpVersion.V0_7_1, GpVersion.V0_7_2];
+export const DEFAULT_SUITE = TestSuite.W3F_DAVXY;
+export const DEFAULT_VERSION = GpVersion.V0_7_2;
+export let CURRENT_VERSION = parseCurrentVersion(env.GP_VERSION) ?? DEFAULT_VERSION;
+export let CURRENT_SUITE = parseCurrentSuite(env.TEST_SUITE) ?? DEFAULT_SUITE;
+function parseCurrentVersion(env) {
+    if (env === undefined) {
+        return undefined;
+    }
+    for (const v of Object.values(GpVersion)) {
+        if (env === v) {
+            return v;
+        }
+    }
+    throw new Error(`Configured environment variable GP_VERSION is unknown: '${env}'. Use one of: ${ALL_VERSIONS_IN_ORDER}`);
+}
+function parseCurrentSuite(env) {
+    if (env === undefined) {
+        return undefined;
+    }
+    for (const s of Object.values(TestSuite)) {
+        if (env === s) {
+            return s;
+        }
+    }
+    throw new Error(`Configured environment variable TEST_SUITE is unknown: '${env}'. Use one of: ${Object.values(TestSuite)}`);
+}
+export class Compatibility {
+    static override(version) {
+        CURRENT_VERSION = version ?? DEFAULT_VERSION;
+    }
+    static overrideSuite(suite) {
+        CURRENT_SUITE = suite;
+    }
+    static is(...version) {
+        if (CURRENT_VERSION === undefined) {
+            return version.includes(DEFAULT_VERSION);
+        }
+        return version.includes(CURRENT_VERSION);
+    }
+    static isSuite(suite, version) {
+        if (CURRENT_SUITE === undefined) {
+            return false;
+        }
+        const isCorrectGPVersion = version === undefined || Compatibility.is(version);
+        return suite === CURRENT_SUITE && isCorrectGPVersion;
+    }
+    static isGreaterOrEqual(version) {
+        const index = ALL_VERSIONS_IN_ORDER.indexOf(version);
+        if (index === -1) {
+            throw new Error(`Invalid version: ${version}. Not found amongst supported versions: ${ALL_VERSIONS_IN_ORDER}`);
+        }
+        return Compatibility.is(...ALL_VERSIONS_IN_ORDER.slice(index));
+    }
+    /**
+     * Allows selecting different values for different Gray Paper versions from one record.
+     *
+     * fallback The default value to return if no value is found for the current.
+     * versions A record mapping versions to values, checking if the version is greater or equal to the current version.
+     * @returns The value for the current version, or the default value.
+     */
+    static selectIfGreaterOrEqual({ fallback, versions, }) {
+        for (const version of ALL_VERSIONS_IN_ORDER.toReversed()) {
+            const value = versions[version];
+            if (value !== undefined && Compatibility.isGreaterOrEqual(version)) {
+                return value;
+            }
+        }
+        return fallback;
+    }
+}

package/packages/core/utils/compatibility.test.d.ts

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

package/packages/core/utils/compatibility.test.d.ts.map

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

package/packages/core/utils/compatibility.test.js

@@ -0,0 +1,77 @@
+import assert from "node:assert";
+import { afterEach, beforeEach, describe, it } from "node:test";
+import { Compatibility, CURRENT_VERSION, DEFAULT_VERSION, GpVersion } from "./compatibility.js";
+describe("GrayPaper compatibility", { concurrency: false }, () => {
+    let savedVersion = CURRENT_VERSION;
+    beforeEach(() => {
+        savedVersion = CURRENT_VERSION;
+    });
+    afterEach(() => {
+        Compatibility.override(savedVersion);
+    });
+    it("Should check with default value if env is not set", () => {
+        Compatibility.override(undefined);
+        const defaultVersion = DEFAULT_VERSION;
+        assert.equal(Compatibility.is(defaultVersion), true);
+    });
+    it("Should check with env variable if env variable was set", () => {
+        const gpVersion = GpVersion.V0_7_0;
+        Compatibility.override(gpVersion);
+        assert.equal(Compatibility.is(gpVersion), true);
+    });
+    it("Should check an order of versions (isGreaterOrEqual)", () => {
+        const gpVersion = GpVersion.V0_7_0;
+        Compatibility.override(gpVersion);
+        assert.equal(Compatibility.isGreaterOrEqual(GpVersion.V0_7_0), true);
+        assert.equal(Compatibility.isGreaterOrEqual(GpVersion.V0_7_1), false);
+        assert.equal(Compatibility.isGreaterOrEqual(GpVersion.V0_7_2), false);
+    });
+    it("Should order values by versions and get the one for highest version matching", () => {
+        const gpVersion = GpVersion.V0_7_1;
+        Compatibility.override(gpVersion);
+        const record = {
+            [GpVersion.V0_7_0]: "low",
+            [GpVersion.V0_7_2]: "high",
+        };
+        const result = Compatibility.selectIfGreaterOrEqual({ fallback: "default", versions: record });
+        assert.equal(result, "low");
+    });
+    it("Should return middle value that is greater or equal current value", () => {
+        const gpVersion = GpVersion.V0_7_1;
+        Compatibility.override(gpVersion);
+        const record = {
+            [GpVersion.V0_7_0]: "low",
+            [GpVersion.V0_7_1]: "mid",
+            [GpVersion.V0_7_2]: "high",
+        };
+        const result = Compatibility.selectIfGreaterOrEqual({ fallback: "default", versions: record });
+        assert.equal(result, "mid");
+    });
+    it("Should return highest value that is greater or equal current value", () => {
+        const gpVersion = GpVersion.V0_7_2;
+        Compatibility.override(gpVersion);
+        const record = {
+            [GpVersion.V0_7_0]: "low",
+            [GpVersion.V0_7_1]: "mid",
+            [GpVersion.V0_7_2]: "high",
+        };
+        const result = Compatibility.selectIfGreaterOrEqual({ fallback: "default", versions: record });
+        assert.equal(result, "high");
+    });
+    it("Should return default if no version is greater or equal", () => {
+        const gpVersion = GpVersion.V0_7_0;
+        Compatibility.override(gpVersion);
+        const record = {
+            [GpVersion.V0_7_1]: "mid",
+            [GpVersion.V0_7_2]: "high",
+        };
+        const result = Compatibility.selectIfGreaterOrEqual({ fallback: "default", versions: record });
+        assert.equal(result, "default");
+    });
+    it("Should return default if record is empty", () => {
+        const gpVersion = GpVersion.V0_7_0;
+        Compatibility.override(gpVersion);
+        const result = Compatibility.selectIfGreaterOrEqual({ fallback: "default", versions: {} });
+        assert.equal(result, "default");
+    });
+});

package/packages/core/utils/debug.d.ts

@@ -0,0 +1,51 @@
+export declare function isBrowser(): boolean;
+/**
+ * Get current time in milliseconds (works in both Node and browser).
+ *
+ * Node.js implementation converts hrtime bigint nanoseconds to milliseconds.
+ * This is safe because dividing nanoseconds by 1_000_000 yields milliseconds,
+ * which remain well below Number.MAX_SAFE_INTEGER for practical runtimes
+ * (would take ~285 years to overflow).
+ */
+export declare const now: () => number;
+/**
+ * A function to perform runtime assertions.
+ *
+ * We avoid using `node:assert` to keep compatibility with a browser environment.
+ * Note the checks should not have any side effects, since we might decide
+ * to remove all of them in a post-processing step.
+ *
+ * NOTE the function is intended to be used as tagged template string for the performance
+ * reasons.
+ */
+export declare function check(strings: TemplateStringsArray, condition: boolean, ...data: unknown[]): asserts condition is true;
+/**
+ * The function can be used to make sure that a particular type is `never`
+ * at some point in the code.
+ *
+ * Basically that means that all other options are exhaustively handled
+ * earlier and the assertion should make sure that an unhandled case
+ * is not introduced in the future.
+ */
+export declare function assertNever(value: never): never;
+/**
+ * The function can be used to make sure that a particular object type
+ * has no keys at a certain point in the code.
+ *
+ * Basically that means that all other possible keys are exhaustively
+ * handled earlier and the assertion should make sure that no unexpected
+ * keys are introduced in the future.
+ */
+export declare function assertEmpty<T extends Record<string, never>>(value: T): void;
+/** Debug print an object. */
+export declare function inspect<T>(val: T): string;
+/** Utility function to measure time taken for some operation [ms]. */
+export declare function measure(id: string): () => string;
+/** A class that adds `toString` method that prints all properties of an object. */
+export declare abstract class WithDebug {
+    toString(): string;
+}
+export declare function lazyInspect<T>(obj: T): {
+    toString(): string;
+};
+//# sourceMappingURL=debug.d.ts.map

package/packages/core/utils/debug.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"debug.d.ts","sourceRoot":"","sources":["../../../../../packages/core/utils/debug.ts"],"names":[],"mappings":"AAAA,wBAAgB,SAAS,YAExB;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,GAAG,cAA6F,CAAC;AAE9G;;;;;;;;;GASG;AACH,wBAAgB,KAAK,CACnB,OAAO,EAAE,oBAAoB,EAC7B,SAAS,EAAE,OAAO,EAClB,GAAG,IAAI,EAAE,OAAO,EAAE,GACjB,OAAO,CAAC,SAAS,IAAI,IAAI,CAO3B;AAED;;;;;;;GAOG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,KAAK,GAAG,KAAK,CAE/C;AAED;;;;;;;GAOG;AACH,wBAAgB,WAAW,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,EAAE,KAAK,EAAE,CAAC,QAKpE;AAED,6BAA6B;AAC7B,wBAAgB,OAAO,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,MAAM,CAqDzC;AAED,sEAAsE;AACtE,wBAAgB,OAAO,CAAC,EAAE,EAAE,MAAM,gBAGjC;AAED,mFAAmF;AACnF,8BAAsB,SAAS;IAC7B,QAAQ;CAGT;AAED,wBAAgB,WAAW,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC;;EAMpC"}

package/packages/core/utils/debug.js

@@ -0,0 +1,117 @@
+export function isBrowser() {
+    return typeof process === "undefined" || typeof process.abort === "undefined";
+}
+/**
+ * Get current time in milliseconds (works in both Node and browser).
+ *
+ * Node.js implementation converts hrtime bigint nanoseconds to milliseconds.
+ * This is safe because dividing nanoseconds by 1_000_000 yields milliseconds,
+ * which remain well below Number.MAX_SAFE_INTEGER for practical runtimes
+ * (would take ~285 years to overflow).
+ */
+export const now = isBrowser() ? () => performance.now() : () => Number(process.hrtime.bigint() / 1000000n);
+/**
+ * A function to perform runtime assertions.
+ *
+ * We avoid using `node:assert` to keep compatibility with a browser environment.
+ * Note the checks should not have any side effects, since we might decide
+ * to remove all of them in a post-processing step.
+ *
+ * NOTE the function is intended to be used as tagged template string for the performance
+ * reasons.
+ */
+export function check(strings, condition, ...data) {
+    if (!condition) {
+        // add an empty value so that `data.length === strings.length`
+        data.unshift("");
+        const message = strings.map((v, index) => `${v}${data[index] ?? ""}`);
+        throw new Error(`Assertion failure:${message.join("")}`);
+    }
+}
+/**
+ * The function can be used to make sure that a particular type is `never`
+ * at some point in the code.
+ *
+ * Basically that means that all other options are exhaustively handled
+ * earlier and the assertion should make sure that an unhandled case
+ * is not introduced in the future.
+ */
+export function assertNever(value) {
+    throw new Error(`Unexpected value: ${value}`);
+}
+/**
+ * The function can be used to make sure that a particular object type
+ * has no keys at a certain point in the code.
+ *
+ * Basically that means that all other possible keys are exhaustively
+ * handled earlier and the assertion should make sure that no unexpected
+ * keys are introduced in the future.
+ */
+export function assertEmpty(value) {
+    const keys = Object.keys(value);
+    if (keys.length > 0) {
+        throw new Error(`Unexpected keys: ${keys.join(", ")}`);
+    }
+}
+/** Debug print an object. */
+export function inspect(val) {
+    const nest = (v) => v
+        .split("\n")
+        .map((x) => `  ${x}`)
+        .join("\n")
+        .trim();
+    if (val === null) {
+        return "<null>";
+    }
+    if (val === undefined) {
+        return "<undefined>";
+    }
+    if (Array.isArray(val)) {
+        return `[${val.map((x) => inspect(x))}]`;
+    }
+    if (val instanceof Map) {
+        return inspect(Array.from(val.entries()));
+    }
+    if (typeof val === "number") {
+        return `${val} (0x${val.toString(16)})`;
+    }
+    if (typeof val !== "object") {
+        return `${val}`;
+    }
+    if ("toString" in val &&
+        Object.prototype.toString !== val.toString &&
+        WithDebug.prototype.toString !== val.toString) {
+        return `${val}`;
+    }
+    const name = val.constructor.name;
+    let v = name !== "Object" ? `${name} {` : "{";
+    const keys = Object.keys(val);
+    const oneLine = keys.length < 3;
+    for (const k of keys) {
+        if (typeof k === "string") {
+            v += oneLine ? "" : "\n  ";
+            v += `${k}: ${nest(inspect(val[k]))}`;
+            v += oneLine ? "," : "";
+        }
+    }
+    v += oneLine ? "}" : "\n}";
+    return v;
+}
+/** Utility function to measure time taken for some operation [ms]. */
+export function measure(id) {
+    const start = now();
+    return () => `${id} took ${(now() - start).toFixed(2)}ms`;
+}
+/** A class that adds `toString` method that prints all properties of an object. */
+export class WithDebug {
+    toString() {
+        return inspect(this);
+    }
+}
+export function lazyInspect(obj) {
+    return {
+        toString() {
+            return inspect(obj);
+        },
+    };
+}

package/packages/core/utils/debug.test.d.ts

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

package/packages/core/utils/debug.test.d.ts.map

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

package/packages/core/utils/debug.test.js

@@ -0,0 +1,25 @@
+import assert from "node:assert";
+import { describe, it } from "node:test";
+import { check, inspect, lazyInspect } from "./debug.js";
+describe("utils::check", () => {
+    it("should do nothing if condition is met", () => {
+        check `${true} I shall not fail!`;
+    });
+    it("should throw exception with message if condition is not met", () => {
+        const num = 10;
+        assert.throws(() => {
+            check `${false} Oopsie ${4}, ${"!"} ${num}`;
+        }, new Error("Assertion failure: Oopsie 4, ! 10"));
+    });
+});
+describe("utils::lazyInspect", () => {
+    it("should correctly print a map", () => {
+        const map = new Map([
+            ["a", 1],
+            ["b", 2],
+        ]);
+        const lazyInspectedMap = `${lazyInspect(map)}`;
+        const expected = inspect(map);
+        assert.strictEqual(lazyInspectedMap, expected);
+    });
+});

package/packages/core/utils/dev.d.ts

@@ -0,0 +1,19 @@
+/**
+ * The function will produce relative path resolver that is adjusted
+ * for package location within the workspace.
+ *
+ * Example:
+ * $ npm start -w @typeberry/jam
+ *
+ * The above command will run `./bin/jam/index.js`, however we would
+ * still want relative paths to be resolved according to top-level workspace
+ * directory.
+ *
+ * So the caller, passes the absolute workspace path as argument and get's
+ * a function that can properly resolve relative paths.
+ *
+ * NOTE: the translation happens only for development build! When
+ * we build a single library from our project, we no longer mangle the paths.
+ */
+export declare const workspacePathFix: (workspacePath: string) => (p: string) => string;
+//# sourceMappingURL=dev.d.ts.map

package/packages/core/utils/dev.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dev.d.ts","sourceRoot":"","sources":["../../../../../packages/core/utils/dev.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,gBAAgB,kBAEP,MAAM,MAAM,GAAG,MAAM,WAMf,CAAC"}

package/packages/core/utils/dev.js

@@ -0,0 +1,26 @@
+import { env } from "./env.js";
+/**
+ * The function will produce relative path resolver that is adjusted
+ * for package location within the workspace.
+ *
+ * Example:
+ * $ npm start -w @typeberry/jam
+ *
+ * The above command will run `./bin/jam/index.js`, however we would
+ * still want relative paths to be resolved according to top-level workspace
+ * directory.
+ *
+ * So the caller, passes the absolute workspace path as argument and get's
+ * a function that can properly resolve relative paths.
+ *
+ * NOTE: the translation happens only for development build! When
+ * we build a single library from our project, we no longer mangle the paths.
+ */
+export const workspacePathFix = env.NODE_ENV === "development"
+    ? (workspacePath) => (p) => {
+        if (p.startsWith("/")) {
+            return p;
+        }
+        return `${workspacePath}/${p}`;
+    }
+    : () => (p) => p;

package/packages/core/utils/env.d.ts

@@ -0,0 +1,2 @@
+export declare const env: NodeJS.ProcessEnv;
+//# sourceMappingURL=env.d.ts.map

package/packages/core/utils/env.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"env.d.ts","sourceRoot":"","sources":["../../../../../packages/core/utils/env.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,GAAG,mBAAoD,CAAC"}

package/packages/core/utils/env.js

@@ -0,0 +1 @@
+export const env = typeof process === "undefined" ? {} : process.env;

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

@@ -0,0 +1,21 @@
+/**
+ * Utilities that are widely used across typeberry.
+ *
+ * BIG FAT NOTE: Please think twice or thrice before adding something here.
+ * The package should really contain only things that are pretty much essential
+ * and used everywhere.
+ *
+ * It might be much better to create a small package just for the thing you
+ * are thinking about adding here. It's easier to later consolide smaller
+ * things into this `utils` package than to split it into separate parts
+ * as an afterthought.
+ */
+export * from "./compatibility.js";
+export * from "./debug.js";
+export * from "./dev.js";
+export * from "./env.js";
+export * from "./opaque.js";
+export * from "./result.js";
+export * from "./safe-alloc-uint8array.js";
+export * from "./test.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../packages/core/utils/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,cAAc,oBAAoB,CAAC;AACnC,cAAc,YAAY,CAAC;AAC3B,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC;AACzB,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,4BAA4B,CAAC;AAC3C,cAAc,WAAW,CAAC"}

package/packages/core/utils/index.js

@@ -0,0 +1,20 @@
+/**
+ * Utilities that are widely used across typeberry.
+ *
+ * BIG FAT NOTE: Please think twice or thrice before adding something here.
+ * The package should really contain only things that are pretty much essential
+ * and used everywhere.
+ *
+ * It might be much better to create a small package just for the thing you
+ * are thinking about adding here. It's easier to later consolide smaller
+ * things into this `utils` package than to split it into separate parts
+ * as an afterthought.
+ */
+export * from "./compatibility.js";
+export * from "./debug.js";
+export * from "./dev.js";
+export * from "./env.js";
+export * from "./opaque.js";
+export * from "./result.js";
+export * from "./safe-alloc-uint8array.js";
+export * from "./test.js";

package/packages/core/utils/opaque.d.ts

@@ -0,0 +1,31 @@
+/**
+ * `Opaque<Type, Token>` constructs a unique type which is a subset of Type with a
+ * specified unique token Token. It means that base type cannot be assigned to unique type by accident.
+ * Good examples of opaque types include:
+ * - JWTs or other tokens - these are special kinds of string used for authorization purposes.
+ *   If your app uses multiple types of tokens each should be a separate opaque type to avoid confusion
+ * - Specific currencies - amount of different currencies shouldn't be mixed
+ * - Bitcoin address - special kind of string
+ *
+ * `type GithubAccessToken = Opaque<string, "GithubAccessToken">;`
+ * `type USD = Opaque<number, "USD">;`
+ * `type PositiveNumber = Opaque<number, "PositiveNumber">;
+ *
+ * More: https://github.com/ts-essentials/ts-essentials/blob/master/lib/opaque/README.md
+ *
+ * Copyright (c) 2018-2019 Chris Kaczor (github.com/krzkaczor)
+ */
+type Uninstantiable = void & {
+    __brand: "uninstantiable";
+};
+type StringLiteral<Type> = Type extends string ? (string extends Type ? never : Type) : never;
+export declare const __OPAQUE_TYPE__: unique symbol;
+export type WithOpaque<Token extends string> = {
+    readonly [__OPAQUE_TYPE__]: Token;
+};
+export type TokenOf<OpaqueType, Type> = OpaqueType extends Opaque<Type, infer Token> ? Token : never;
+export type Opaque<Type, Token extends string> = Token extends StringLiteral<Token> ? Type & WithOpaque<Token> : Uninstantiable;
+export declare function asOpaqueType<T, Token extends string>(v: T): Opaque<T, Token>;
+export declare function seeThrough<T, Token extends string>(v: Opaque<T, Token>): T;
+export {};
+//# sourceMappingURL=opaque.d.ts.map

package/packages/core/utils/opaque.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"opaque.d.ts","sourceRoot":"","sources":["../../../../../packages/core/utils/opaque.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAGH,KAAK,cAAc,GAAG,IAAI,GAAG;IAAE,OAAO,EAAE,gBAAgB,CAAA;CAAE,CAAC;AAE3D,KAAK,aAAa,CAAC,IAAI,IAAI,IAAI,SAAS,MAAM,GAAG,CAAC,MAAM,SAAS,IAAI,GAAG,KAAK,GAAG,IAAI,CAAC,GAAG,KAAK,CAAC;AAE9F,MAAM,CAAC,OAAO,CAAC,MAAM,eAAe,EAAE,OAAO,MAAM,CAAC;AAEpD,MAAM,MAAM,UAAU,CAAC,KAAK,SAAS,MAAM,IAAI;IAC7C,QAAQ,CAAC,CAAC,eAAe,CAAC,EAAE,KAAK,CAAC;CACnC,CAAC;AAEF,MAAM,MAAM,OAAO,CAAC,UAAU,EAAE,IAAI,IAAI,UAAU,SAAS,MAAM,CAAC,IAAI,EAAE,MAAM,KAAK,CAAC,GAAG,KAAK,GAAG,KAAK,CAAC;AAErG,MAAM,MAAM,MAAM,CAAC,IAAI,EAAE,KAAK,SAAS,MAAM,IAAI,KAAK,SAAS,aAAa,CAAC,KAAK,CAAC,GAC/E,IAAI,GAAG,UAAU,CAAC,KAAK,CAAC,GACxB,cAAc,CAAC;AAEnB,wBAAgB,YAAY,CAAC,CAAC,EAAE,KAAK,SAAS,MAAM,EAAE,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,CAAC,EAAE,KAAK,CAAC,CAE5E;AACD,wBAAgB,UAAU,CAAC,CAAC,EAAE,KAAK,SAAS,MAAM,EAAE,CAAC,EAAE,MAAM,CAAC,CAAC,EAAE,KAAK,CAAC,GAAG,CAAC,CAE1E"}

package/packages/core/utils/opaque.js

@@ -0,0 +1,23 @@
+/**
+ * `Opaque<Type, Token>` constructs a unique type which is a subset of Type with a
+ * specified unique token Token. It means that base type cannot be assigned to unique type by accident.
+ * Good examples of opaque types include:
+ * - JWTs or other tokens - these are special kinds of string used for authorization purposes.
+ *   If your app uses multiple types of tokens each should be a separate opaque type to avoid confusion
+ * - Specific currencies - amount of different currencies shouldn't be mixed
+ * - Bitcoin address - special kind of string
+ *
+ * `type GithubAccessToken = Opaque<string, "GithubAccessToken">;`
+ * `type USD = Opaque<number, "USD">;`
+ * `type PositiveNumber = Opaque<number, "PositiveNumber">;
+ *
+ * More: https://github.com/ts-essentials/ts-essentials/blob/master/lib/opaque/README.md
+ *
+ * Copyright (c) 2018-2019 Chris Kaczor (github.com/krzkaczor)
+ */
+export function asOpaqueType(v) {
+    return v;
+}
+export function seeThrough(v) {
+    return v;
+}

package/packages/core/utils/result.d.ts

@@ -0,0 +1,48 @@
+/** An indication of two possible outcomes returned from a function. */
+export type Result<Ok, Error> = OkResult<Ok> | ErrorResult<Error>;
+export type OkResult<Ok> = {
+    isOk: true;
+    isError: false;
+    ok: Ok;
+};
+export type ErrorResult<Error> = {
+    isOk: false;
+    isError: true;
+    error: Error;
+    details: () => string;
+};
+/**
+ * A generic `OK` response to be used instead of some empty/null value.
+ *
+ * NOTE that generic error is not provided to rather have a more
+ * descriptive value.
+ */
+export declare const OK: unique symbol;
+export type OK = typeof OK;
+/**
+ * A standardized tagged union for nested error types.
+ */
+export type TaggedError<Kind, Nested> = {
+    kind: Kind;
+    error: Nested;
+};
+type EnumMapping = Record<string, string | number>;
+declare class RichTaggedError<Kind extends string | number, Nested> implements TaggedError<Kind, Nested> {
+    readonly kind: Kind;
+    readonly error: Nested;
+    readonly enumMapping: EnumMapping;
+    constructor(kind: Kind, error: Nested, enumMapping: EnumMapping);
+    toString(): string;
+}
+export declare function resultToString<Ok, Error>(res: Result<Ok, Error>): string;
+/** An indication of two possible outcomes returned from a function. */
+export declare const Result: {
+    /** Create new [`Result`] with `Ok` status. */
+    ok: <Ok>(ok: Ok) => OkResult<Ok>;
+    /** Create new [`Result`] with `Error` status. */
+    error: <Error>(error: Error, details: () => string) => ErrorResult<Error>;
+    /** Create new [`Result`] with `Error` coming from a nested error type. */
+    taggedError: <Ok, Kind extends string | number, Nested>(enumMapping: EnumMapping, kind: Kind, nested: ErrorResult<Nested>) => Result<Ok, RichTaggedError<Kind, Nested>>;
+};
+export {};
+//# sourceMappingURL=result.d.ts.map

package/packages/core/utils/result.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"result.d.ts","sourceRoot":"","sources":["../../../../../packages/core/utils/result.ts"],"names":[],"mappings":"AAEA,uEAAuE;AACvE,MAAM,MAAM,MAAM,CAAC,EAAE,EAAE,KAAK,IAAI,QAAQ,CAAC,EAAE,CAAC,GAAG,WAAW,CAAC,KAAK,CAAC,CAAC;AAElE,MAAM,MAAM,QAAQ,CAAC,EAAE,IAAI;IACzB,IAAI,EAAE,IAAI,CAAC;IACX,OAAO,EAAE,KAAK,CAAC;IACf,EAAE,EAAE,EAAE,CAAC;CACR,CAAC;AAEF,MAAM,MAAM,WAAW,CAAC,KAAK,IAAI;IAC/B,IAAI,EAAE,KAAK,CAAC;IACZ,OAAO,EAAE,IAAI,CAAC;IACd,KAAK,EAAE,KAAK,CAAC;IACb,OAAO,EAAE,MAAM,MAAM,CAAC;CACvB,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,EAAE,eAAe,CAAC;AAC/B,MAAM,MAAM,EAAE,GAAG,OAAO,EAAE,CAAC;AAE3B;;GAEG;AACH,MAAM,MAAM,WAAW,CAAC,IAAI,EAAE,MAAM,IAAI;IACtC,IAAI,EAAE,IAAI,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,KAAK,WAAW,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,CAAC;AAEnD,cAAM,eAAe,CAAC,IAAI,SAAS,MAAM,GAAG,MAAM,EAAE,MAAM,CAAE,YAAW,WAAW,CAAC,IAAI,EAAE,MAAM,CAAC;aAE5E,IAAI,EAAE,IAAI;aACV,KAAK,EAAE,MAAM;aACb,WAAW,EAAE,WAAW;gBAFxB,IAAI,EAAE,IAAI,EACV,KAAK,EAAE,MAAM,EACb,WAAW,EAAE,WAAW;IAG1C,QAAQ;CAIT;AAwBD,wBAAgB,cAAc,CAAC,EAAE,EAAE,KAAK,EAAE,GAAG,EAAE,MAAM,CAAC,EAAE,EAAE,KAAK,CAAC,UAK/D;AAED,uEAAuE;AACvE,eAAO,MAAM,MAAM;IACjB,8CAA8C;SACzC,EAAE,MAAM,EAAE,KAAG,QAAQ,CAAC,EAAE,CAAC;IAS9B,iDAAiD;YACzC,KAAK,SAAS,KAAK,WAAW,MAAM,MAAM,KAAG,WAAW,CAAC,KAAK,CAAC;IAUvE,0EAA0E;kBAC5D,EAAE,EAAE,IAAI,SAAS,MAAM,GAAG,MAAM,EAAE,MAAM,eACvC,WAAW,QAClB,IAAI,UACF,WAAW,CAAC,MAAM,CAAC,KAC1B,MAAM,CAAC,EAAE,EAAE,eAAe,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;CAG7C,CAAC"}