@nimbus-cqrs/eventsourcingdb 2.4.0 → 3.0.0-beta.1

package/esm/deps/jsr.io/@std/ulid/1.0.0/_util.d.ts

@@ -1,14 +0,0 @@
-/** Type for a ULID generator function. */
-export type ULID = (seedTime?: number) => string;
-export declare const ENCODING = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
-export declare const ENCODING_LEN: number;
-export declare const TIME_MAX: number;
-export declare const TIME_LEN = 10;
-export declare const RANDOM_LEN = 16;
-export declare const ULID_LEN: number;
-export declare function encodeTime(timestamp: number): string;
-export declare function encodeRandom(): string;
-export declare function incrementBase32(str: string): string;
-/** Generates a monotonically increasing ULID. */
-export declare function monotonicFactory(encodeRand?: typeof encodeRandom): ULID;
-//# sourceMappingURL=_util.d.ts.map

package/esm/deps/jsr.io/@std/ulid/1.0.0/_util.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"_util.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/ulid/1.0.0/_util.ts"],"names":[],"mappings":"AAEA,0CAA0C;AAC1C,MAAM,MAAM,IAAI,GAAG,CAAC,QAAQ,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC;AAIjD,eAAO,MAAM,QAAQ,qCAAqC,CAAC;AAC3D,eAAO,MAAM,YAAY,QAAkB,CAAC;AAC5C,eAAO,MAAM,QAAQ,QAAsB,CAAC;AAC5C,eAAO,MAAM,QAAQ,KAAK,CAAC;AAC3B,eAAO,MAAM,UAAU,KAAK,CAAC;AAC7B,eAAO,MAAM,QAAQ,QAAwB,CAAC;AAM9C,wBAAgB,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAapD;AAED,wBAAgB,YAAY,IAAI,MAAM,CAOrC;AAED,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAkBnD;AAED,iDAAiD;AACjD,wBAAgB,gBAAgB,CAAC,UAAU,sBAAe,GAAG,IAAI,CAYhE"}

package/esm/deps/jsr.io/@std/ulid/1.0.0/_util.js

@@ -1,65 +0,0 @@
-// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
-// These values should NEVER change. If
-// they do, we're no longer making ulids!
-export const ENCODING = "0123456789ABCDEFGHJKMNPQRSTVWXYZ"; // Crockford's Base32
-export const ENCODING_LEN = ENCODING.length;
-export const TIME_MAX = Math.pow(2, 48) - 1;
-export const TIME_LEN = 10;
-export const RANDOM_LEN = 16;
-export const ULID_LEN = TIME_LEN + RANDOM_LEN;
-function replaceCharAt(str, index, char) {
-    return str.substring(0, index) + char + str.substring(index + 1);
-}
-export function encodeTime(timestamp) {
-    if (!Number.isInteger(timestamp) || timestamp < 0 || timestamp > TIME_MAX) {
-        throw new RangeError(`Time must be a positive integer less than ${TIME_MAX}`);
-    }
-    let str = "";
-    for (let len = TIME_LEN; len > 0; len--) {
-        const mod = timestamp % ENCODING_LEN;
-        str = ENCODING[mod] + str;
-        timestamp = Math.floor(timestamp / ENCODING_LEN);
-    }
-    return str;
-}
-export function encodeRandom() {
-    let str = "";
-    const bytes = crypto.getRandomValues(new Uint8Array(RANDOM_LEN));
-    for (const byte of bytes) {
-        str += ENCODING[byte % ENCODING_LEN];
-    }
-    return str;
-}
-export function incrementBase32(str) {
-    let index = str.length;
-    let char;
-    let charIndex;
-    const maxCharIndex = ENCODING_LEN - 1;
-    while (--index >= 0) {
-        char = str[index];
-        charIndex = ENCODING.indexOf(char);
-        if (charIndex === -1) {
-            throw new TypeError("Incorrectly encoded string");
-        }
-        if (charIndex === maxCharIndex) {
-            str = replaceCharAt(str, index, ENCODING[0]);
-            continue;
-        }
-        return replaceCharAt(str, index, ENCODING[charIndex + 1]);
-    }
-    throw new Error("Cannot increment this string");
-}
-/** Generates a monotonically increasing ULID. */
-export function monotonicFactory(encodeRand = encodeRandom) {
-    let lastTime = 0;
-    let lastRandom;
-    return function ulid(seedTime = Date.now()) {
-        if (seedTime <= lastTime) {
-            const incrementedRandom = (lastRandom = incrementBase32(lastRandom));
-            return encodeTime(lastTime) + incrementedRandom;
-        }
-        lastTime = seedTime;
-        const newRandom = (lastRandom = encodeRand());
-        return encodeTime(seedTime) + newRandom;
-    };
-}

package/esm/deps/jsr.io/@std/ulid/1.0.0/decode_time.d.ts

@@ -1,20 +0,0 @@
-/**
- * Extracts the number of milliseconds since the Unix epoch that had passed when
- * the ULID was generated. If the ULID is malformed, an error will be thrown.
- *
- * @example Decode the time from a ULID
- * ```ts
- * import { decodeTime, ulid } from "@std/ulid";
- * import { assertEquals } from "@std/assert";
- *
- * const timestamp = 150_000;
- * const ulidString = ulid(timestamp);
- *
- * assertEquals(decodeTime(ulidString), timestamp);
- * ```
- *
- * @param ulid The ULID to extract the timestamp from.
- * @returns The number of milliseconds since the Unix epoch that had passed when the ULID was generated.
- */
-export declare function decodeTime(ulid: string): number;
-//# sourceMappingURL=decode_time.d.ts.map

package/esm/deps/jsr.io/@std/ulid/1.0.0/decode_time.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"decode_time.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/ulid/1.0.0/decode_time.ts"],"names":[],"mappings":"AAaA;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAqB/C"}

package/esm/deps/jsr.io/@std/ulid/1.0.0/decode_time.js

@@ -1,43 +0,0 @@
-// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
-// Copyright 2023 Yoshiya Hinosawa. All rights reserved. MIT license.
-// Copyright 2017 Alizain Feerasta. All rights reserved. MIT license.
-// This module is browser compatible.
-import { ENCODING, ENCODING_LEN, TIME_LEN, TIME_MAX, ULID_LEN, } from "./_util.js";
-/**
- * Extracts the number of milliseconds since the Unix epoch that had passed when
- * the ULID was generated. If the ULID is malformed, an error will be thrown.
- *
- * @example Decode the time from a ULID
- * ```ts
- * import { decodeTime, ulid } from "@std/ulid";
- * import { assertEquals } from "@std/assert";
- *
- * const timestamp = 150_000;
- * const ulidString = ulid(timestamp);
- *
- * assertEquals(decodeTime(ulidString), timestamp);
- * ```
- *
- * @param ulid The ULID to extract the timestamp from.
- * @returns The number of milliseconds since the Unix epoch that had passed when the ULID was generated.
- */
-export function decodeTime(ulid) {
-    if (ulid.length !== ULID_LEN) {
-        throw new Error(`ULID must be exactly ${ULID_LEN} characters long`);
-    }
-    const time = ulid
-        .substring(0, TIME_LEN)
-        .split("")
-        .reverse()
-        .reduce((carry, char, index) => {
-        const encodingIndex = ENCODING.indexOf(char);
-        if (encodingIndex === -1) {
-            throw new Error(`Invalid ULID character found: ${char}`);
-        }
-        return (carry += encodingIndex * Math.pow(ENCODING_LEN, index));
-    }, 0);
-    if (time > TIME_MAX) {
-        throw new RangeError(`ULID timestamp component exceeds maximum value of ${TIME_MAX}`);
-    }
-    return time;
-}

package/esm/deps/jsr.io/@std/ulid/1.0.0/mod.d.ts

@@ -1,44 +0,0 @@
-/**
- * Utilities for generating and working with
- * {@link https://github.com/ulid/spec | Universally Unique Lexicographically Sortable Identifiers (ULIDs)}.
- *
- * To generate a ULID use the {@linkcode ulid} function. This will generate a
- * ULID based on the current time.
- *
- * ```ts no-assert
- * import { ulid } from "@std/ulid";
- *
- * ulid(); // 01HYFKMDF3HVJ4J3JZW8KXPVTY
- * ```
- *
- * {@linkcode ulid} does not guarantee that the ULIDs will be strictly
- * increasing for the same current time. If you need to guarantee that the ULIDs
- * will be strictly increasing, even for the same current time, use the
- * {@linkcode monotonicUlid} function.
- *
- * ```ts no-assert
- * import { monotonicUlid } from "@std/ulid";
- *
- * monotonicUlid(); // 01HYFKHG5F8RHM2PM3D7NSTDAS
- * monotonicUlid(); // 01HYFKHG5F8RHM2PM3D7NSTDAT
- * ```
- *
- * Because each ULID encodes the time it was generated, you can extract the
- * timestamp from a ULID using the {@linkcode decodeTime} function.
- *
- * ```ts
- * import { decodeTime, ulid } from "@std/ulid";
- * import { assertEquals } from "@std/assert";
- *
- * const timestamp = 150_000;
- * const ulidString = ulid(timestamp);
- *
- * assertEquals(decodeTime(ulidString), timestamp);
- * ```
- *
- * @module
- */
-export * from "./decode_time.js";
-export * from "./monotonic_ulid.js";
-export * from "./ulid.js";
-//# sourceMappingURL=mod.d.ts.map

package/esm/deps/jsr.io/@std/ulid/1.0.0/mod.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/ulid/1.0.0/mod.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AAEH,cAAc,kBAAkB,CAAC;AACjC,cAAc,qBAAqB,CAAC;AACpC,cAAc,WAAW,CAAC"}

package/esm/deps/jsr.io/@std/ulid/1.0.0/mod.js

@@ -1,47 +0,0 @@
-// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
-// Copyright 2023 Yoshiya Hinosawa. All rights reserved. MIT license.
-// Copyright 2017 Alizain Feerasta. All rights reserved. MIT license.
-// This module is browser compatible.
-/**
- * Utilities for generating and working with
- * {@link https://github.com/ulid/spec | Universally Unique Lexicographically Sortable Identifiers (ULIDs)}.
- *
- * To generate a ULID use the {@linkcode ulid} function. This will generate a
- * ULID based on the current time.
- *
- * ```ts no-assert
- * import { ulid } from "@std/ulid";
- *
- * ulid(); // 01HYFKMDF3HVJ4J3JZW8KXPVTY
- * ```
- *
- * {@linkcode ulid} does not guarantee that the ULIDs will be strictly
- * increasing for the same current time. If you need to guarantee that the ULIDs
- * will be strictly increasing, even for the same current time, use the
- * {@linkcode monotonicUlid} function.
- *
- * ```ts no-assert
- * import { monotonicUlid } from "@std/ulid";
- *
- * monotonicUlid(); // 01HYFKHG5F8RHM2PM3D7NSTDAS
- * monotonicUlid(); // 01HYFKHG5F8RHM2PM3D7NSTDAT
- * ```
- *
- * Because each ULID encodes the time it was generated, you can extract the
- * timestamp from a ULID using the {@linkcode decodeTime} function.
- *
- * ```ts
- * import { decodeTime, ulid } from "@std/ulid";
- * import { assertEquals } from "@std/assert";
- *
- * const timestamp = 150_000;
- * const ulidString = ulid(timestamp);
- *
- * assertEquals(decodeTime(ulidString), timestamp);
- * ```
- *
- * @module
- */
-export * from "./decode_time.js";
-export * from "./monotonic_ulid.js";
-export * from "./ulid.js";

package/esm/deps/jsr.io/@std/ulid/1.0.0/monotonic_ulid.d.ts

@@ -1,44 +0,0 @@
-/**
- * Generate a ULID that monotonically increases even for the same millisecond,
- * optionally passing the current time. If the current time is not passed, it
- * will default to `Date.now()`.
- *
- * Unlike the {@linkcode ulid} function, this function is guaranteed to return
- * strictly increasing ULIDs, even for the same seed time, but only if the seed
- * time only ever increases. If the seed time ever goes backwards, the ULID will
- * still be generated, but it will not be guaranteed to be monotonic with
- * previous ULIDs for that same seed time.
- *
- * @example Generate a monotonic ULID
- * ```ts no-assert
- * import { monotonicUlid } from "@std/ulid";
- *
- * monotonicUlid(); // 01HYFKHG5F8RHM2PM3D7NSTDAS
- * monotonicUlid(); // 01HYFKHG5F8RHM2PM3D7NSTDAT
- * monotonicUlid(); // 01HYFKHHX8H4BRY8BYHAV1BZ2T
- * ```
- *
- * @example Generate a monotonic ULID with a seed time
- * ```ts no-assert
- * import { monotonicUlid } from "@std/ulid";
- *
- * // Strict ordering for the same timestamp, by incrementing the least-significant random bit by 1
- * monotonicUlid(150000); // 0000004JFHJJ2Z7X64FN2B4F1Q
- * monotonicUlid(150000); // 0000004JFHJJ2Z7X64FN2B4F1R
- * monotonicUlid(150000); // 0000004JFHJJ2Z7X64FN2B4F1S
- * monotonicUlid(150000); // 0000004JFHJJ2Z7X64FN2B4F1T
- * monotonicUlid(150000); // 0000004JFHJJ2Z7X64FN2B4F1U
- *
- * // A different timestamp will reset the random bits
- * monotonicUlid(150001); // 0000004JFHJJ2Z7X64FN2B4F1P
- *
- * // A previous seed time will not guarantee ordering, and may result in a
- * // ULID lower than one with the same seed time generated previously
- * monotonicUlid(150000); // 0000004JFJ7XF6D76ES95SZR0X
- * ```
- *
- * @param seedTime The time to base the ULID on, in milliseconds since the Unix epoch. Defaults to `Date.now()`.
- * @returns A ULID that is guaranteed to be strictly increasing for the same seed time.
- */
-export declare function monotonicUlid(seedTime?: number): string;
-//# sourceMappingURL=monotonic_ulid.d.ts.map

package/esm/deps/jsr.io/@std/ulid/1.0.0/monotonic_ulid.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"monotonic_ulid.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/ulid/1.0.0/monotonic_ulid.ts"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,wBAAgB,aAAa,CAAC,QAAQ,GAAE,MAAmB,GAAG,MAAM,CAEnE"}

package/esm/deps/jsr.io/@std/ulid/1.0.0/monotonic_ulid.js

@@ -1,51 +0,0 @@
-// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
-// Copyright 2023 Yoshiya Hinosawa. All rights reserved. MIT license.
-// Copyright 2017 Alizain Feerasta. All rights reserved. MIT license.
-// This module is browser compatible.
-import { monotonicFactory } from "./_util.js";
-const defaultMonotonicUlid = monotonicFactory();
-/**
- * Generate a ULID that monotonically increases even for the same millisecond,
- * optionally passing the current time. If the current time is not passed, it
- * will default to `Date.now()`.
- *
- * Unlike the {@linkcode ulid} function, this function is guaranteed to return
- * strictly increasing ULIDs, even for the same seed time, but only if the seed
- * time only ever increases. If the seed time ever goes backwards, the ULID will
- * still be generated, but it will not be guaranteed to be monotonic with
- * previous ULIDs for that same seed time.
- *
- * @example Generate a monotonic ULID
- * ```ts no-assert
- * import { monotonicUlid } from "@std/ulid";
- *
- * monotonicUlid(); // 01HYFKHG5F8RHM2PM3D7NSTDAS
- * monotonicUlid(); // 01HYFKHG5F8RHM2PM3D7NSTDAT
- * monotonicUlid(); // 01HYFKHHX8H4BRY8BYHAV1BZ2T
- * ```
- *
- * @example Generate a monotonic ULID with a seed time
- * ```ts no-assert
- * import { monotonicUlid } from "@std/ulid";
- *
- * // Strict ordering for the same timestamp, by incrementing the least-significant random bit by 1
- * monotonicUlid(150000); // 0000004JFHJJ2Z7X64FN2B4F1Q
- * monotonicUlid(150000); // 0000004JFHJJ2Z7X64FN2B4F1R
- * monotonicUlid(150000); // 0000004JFHJJ2Z7X64FN2B4F1S
- * monotonicUlid(150000); // 0000004JFHJJ2Z7X64FN2B4F1T
- * monotonicUlid(150000); // 0000004JFHJJ2Z7X64FN2B4F1U
- *
- * // A different timestamp will reset the random bits
- * monotonicUlid(150001); // 0000004JFHJJ2Z7X64FN2B4F1P
- *
- * // A previous seed time will not guarantee ordering, and may result in a
- * // ULID lower than one with the same seed time generated previously
- * monotonicUlid(150000); // 0000004JFJ7XF6D76ES95SZR0X
- * ```
- *
- * @param seedTime The time to base the ULID on, in milliseconds since the Unix epoch. Defaults to `Date.now()`.
- * @returns A ULID that is guaranteed to be strictly increasing for the same seed time.
- */
-export function monotonicUlid(seedTime = Date.now()) {
-    return defaultMonotonicUlid(seedTime);
-}

package/esm/deps/jsr.io/@std/ulid/1.0.0/ulid.d.ts

@@ -1,31 +0,0 @@
-/**
- * Generate a ULID, optionally based on a given timestamp. If the timestamp is
- * not passed, it will default to `Date.now()`.
- *
- * Multiple calls to this function with the same seed time will not guarantee
- * that the ULIDs will be strictly increasing, even if the seed time is the
- * same. For that, use the {@linkcode monotonicUlid} function.
- *
- * @example Generate a ULID
- * ```ts no-assert
- * import { ulid } from "@std/ulid";
- *
- * ulid(); // 01HYFKMDF3HVJ4J3JZW8KXPVTY
- * ulid(); // 01HYFKMDF3D2P7G502B9Z2VKV0
- * ulid(); // 01HYFKMDZQ7JD17CRKDXQSZ3Z4
- * ```
- *
- * @example Generate a ULID with a seed time
- * ```ts no-assert
- * import { ulid } from "@std/ulid";
- *
- * ulid(150000); // 0000004JFG3EKDRE04TVVDJW7K
- * ulid(150000); // 0000004JFGN0KHBH0447AK895X
- * ulid(150000); // 0000004JFGMRDH0PN7SM8BZN06
- * ```
- *
- * @param seedTime The time to base the ULID on, in milliseconds since the Unix epoch. Defaults to `Date.now()`.
- * @returns A ULID.
- */
-export declare function ulid(seedTime?: number): string;
-//# sourceMappingURL=ulid.d.ts.map

package/esm/deps/jsr.io/@std/ulid/1.0.0/ulid.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ulid.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/ulid/1.0.0/ulid.ts"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,IAAI,CAAC,QAAQ,GAAE,MAAmB,GAAG,MAAM,CAE1D"}

package/esm/deps/jsr.io/@std/ulid/1.0.0/ulid.js

@@ -1,37 +0,0 @@
-// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
-// Copyright 2023 Yoshiya Hinosawa. All rights reserved. MIT license.
-// Copyright 2017 Alizain Feerasta. All rights reserved. MIT license.
-// This module is browser compatible.
-import { encodeRandom, encodeTime } from "./_util.js";
-/**
- * Generate a ULID, optionally based on a given timestamp. If the timestamp is
- * not passed, it will default to `Date.now()`.
- *
- * Multiple calls to this function with the same seed time will not guarantee
- * that the ULIDs will be strictly increasing, even if the seed time is the
- * same. For that, use the {@linkcode monotonicUlid} function.
- *
- * @example Generate a ULID
- * ```ts no-assert
- * import { ulid } from "@std/ulid";
- *
- * ulid(); // 01HYFKMDF3HVJ4J3JZW8KXPVTY
- * ulid(); // 01HYFKMDF3D2P7G502B9Z2VKV0
- * ulid(); // 01HYFKMDZQ7JD17CRKDXQSZ3Z4
- * ```
- *
- * @example Generate a ULID with a seed time
- * ```ts no-assert
- * import { ulid } from "@std/ulid";
- *
- * ulid(150000); // 0000004JFG3EKDRE04TVVDJW7K
- * ulid(150000); // 0000004JFGN0KHBH0447AK895X
- * ulid(150000); // 0000004JFGMRDH0PN7SM8BZN06
- * ```
- *
- * @param seedTime The time to base the ULID on, in milliseconds since the Unix epoch. Defaults to `Date.now()`.
- * @returns A ULID.
- */
-export function ulid(seedTime = Date.now()) {
-    return encodeTime(seedTime) + encodeRandom();
-}

package/esm/index.d.ts

@@ -1,7 +0,0 @@
-import "./_dnt.polyfills.js";
-export * from './lib/client.js';
-export * from './lib/eventMapping.js';
-export * from './lib/eventObserver.js';
-export * from './lib/readEvents.js';
-export * from './lib/writeEvents.js';
-//# sourceMappingURL=index.d.ts.map

package/esm/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,qBAAqB,CAAC;AAC7B,cAAc,iBAAiB,CAAC;AAChC,cAAc,uBAAuB,CAAC;AACtC,cAAc,wBAAwB,CAAC;AACvC,cAAc,qBAAqB,CAAC;AACpC,cAAc,sBAAsB,CAAC"}

package/esm/index.js

@@ -1,6 +0,0 @@
-import "./_dnt.polyfills.js";
-export * from './lib/client.js';
-export * from './lib/eventMapping.js';
-export * from './lib/eventObserver.js';
-export * from './lib/readEvents.js';
-export * from './lib/writeEvents.js';

package/esm/lib/eventMapping.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"eventMapping.d.ts","sourceRoot":"","sources":["../../src/lib/eventMapping.ts"],"names":[],"mappings":"AAAA,OAAO,EAGH,KAAK,KAAK,EACb,MAAM,qDAAqD,CAAC;AAE7D,OAAO,KAAK,EACR,KAAK,IAAI,oBAAoB,EAC7B,cAAc,EACjB,MAAM,iBAAiB,CAAC;AAEzB;;;;;;GAMG;AACH,MAAM,MAAM,mBAAmB,GAAG;IAC9B,aAAa,EAAE,MAAM,CAAC;IACtB,UAAU,CAAC,EAAE,MAAM,CAAC;CACvB,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,MAAM,SAAS,GAAG;IACpB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACjC,UAAU,EAAE,mBAAmB,CAAC;CACnC,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,WAAW,GAAI,MAAM,OAAO,KAAG,IAAI,IAAI,SAOnD,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,0CAA0C,GACnD,OAAO,KAAK,EACZ,cAAc,MAAM,EACpB,aAAa,MAAM,KACpB,cAeF,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,iCAAiC,GAAI,MAAM,SAAS,KAAK,EAClE,sBAAsB,oBAAoB,KAC3C,MAwBF,CAAC"}

package/esm/lib/eventObserver.d.ts

@@ -1,133 +0,0 @@
-import type { Event as EventSourcingDBEvent } from 'eventsourcingdb';
-type Bound = {
-    id: string;
-    type: 'inclusive' | 'exclusive';
-};
-type ObserveFromLatestEvent = {
-    subject: string;
-    type: string;
-    ifEventIsMissing: 'read-everything' | 'wait-for-event';
-};
-export type RetryOptions = {
-    /**
-     * The maximum number of retries after the initial attempt
-     * before giving up. Defaults to 3 (4 failed attempts total).
-     */
-    maxRetries: number;
-    /**
-     * The initial delay in milliseconds before the first retry.
-     * Subsequent retries will use exponential backoff with jitter.
-     * Defaults to 3000ms.
-     */
-    initialRetryDelayMs: number;
-};
-/**
- * An event observer defines a handler function which will be applied to each event
- * and the options to observe the events according to the EventSourcingDB API.
- *
- * See https://docs.eventsourcingdb.io/getting-started/observing-events for more information.
- */
-export type EventObserver = {
-    /**
-     * The subject of the events to observe.
-     */
-    subject: string;
-    /**
-     * Whether to observe events recursively.
-     * Defaults to false.
-     */
-    recursive?: boolean;
-    /**
-     * The lower bound of the events to observe.
-     * Defaults to undefined.
-     */
-    lowerBound?: Bound;
-    /**
-     * The from latest event to observe.
-     * Defaults to undefined.
-     */
-    fromLatestEvent?: ObserveFromLatestEvent;
-    /**
-     * The event handler which will be called when an event is observed.
-     *
-     * @param event - The EventSourcingDB event that was observed.
-     * @returns A promise that resolves when the event has been handled.
-     */
-    eventHandler: (event: EventSourcingDBEvent) => Promise<void> | void;
-    /**
-     * Options for retry behavior when the observe stream / connection fails.
-     * Uses exponential backoff with jitter between reconnects.
-     * Defaults to { maxRetries: 3, initialRetryDelayMs: 3000 }.
-     */
-    connectionRetryOptions?: RetryOptions;
-    /**
-     * Options for retry behavior when {@link eventHandler} throws.
-     * Handler retries happen in-place without reconnecting the stream.
-     * Defaults to { maxRetries: 3, initialRetryDelayMs: 3000 }.
-     */
-    handlerRetryOptions?: RetryOptions;
-    /**
-     * @deprecated Use {@link connectionRetryOptions} instead.
-     *
-     * Options for retry behavior when the observe stream / connection fails.
-     * Ignored when {@link connectionRetryOptions} is set.
-     */
-    retryOptions?: RetryOptions;
-    /**
-     * Called when {@link eventHandler} keeps failing after all handler
-     * retries are exhausted. The event is then skipped and observation
-     * continues. When omitted, a critical log entry is emitted instead.
-     *
-     * @param error - The last error thrown by the handler.
-     * @param event - The event that could not be handled.
-     */
-    onHandlerError?: (error: Error, event: EventSourcingDBEvent) => Promise<void> | void;
-};
-/**
- * Calculates an exponential backoff delay with jitter for a given
- * retry attempt. The jitter adds up to 30% of the base delay to
- * avoid thundering-herd effects.
- *
- * @param initialDelayMs - The base delay in milliseconds before
- *   exponential scaling.
- * @param attempt - The zero-based retry attempt number.
- * @returns The backoff delay in milliseconds.
- *
- * @deprecated Import {@link calculateBackoffDelay} from
- *   `@nimbus-cqrs/core` instead. This wrapper keeps the historical
- *   30% jitter default used by EventSourcingDB observers.
- */
-export declare const calculateBackoffDelay: (initialDelayMs: number, attempt: number) => number;
-/**
- * Starts observing events for the given {@link EventObserver} with
- * automatic reconnection on stream failure and separate in-place
- * retries for handler failures.
- *
- * Events are consumed from the stream and each one is passed to the
- * observer's event handler inside an OpenTelemetry span. If the event
- * carries a `traceparent`, the span is linked to the original writer's
- * trace for end-to-end distributed tracing.
- *
- * Handler failures are retried without reconnecting. After handler
- * retries are exhausted the event is skipped (lower bound advanced)
- * so observation can continue. When the connection drops, exponential
- * backoff with jitter is applied up to the configured maximum number
- * of connection retries.
- *
- * @param eventObserver - The event observer configuration.
- * @returns A promise that resolves when the observe stream ends or
- *   connection retries are exhausted.
- */
-export declare const observeWithRetry: (eventObserver: EventObserver) => Promise<void>;
-/**
- * Initializes an event observer by starting the observation loop in
- * the background (non-blocking). The observer will keep running and
- * reconnecting according to its connection retry options until the
- * stream ends or connection retries are exhausted. Handler failures
- * are retried separately and do not stop the observer.
- *
- * @param eventObserver - The event observer configuration.
- */
-export declare const initEventObserver: (eventObserver: EventObserver) => void;
-export {};
-//# sourceMappingURL=eventObserver.d.ts.map

package/esm/lib/eventObserver.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"eventObserver.d.ts","sourceRoot":"","sources":["../../src/lib/eventObserver.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,KAAK,IAAI,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AAarE,KAAK,KAAK,GAAG;IACT,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,WAAW,GAAG,WAAW,CAAC;CACnC,CAAC;AAEF,KAAK,sBAAsB,GAAG;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,gBAAgB,EAAE,iBAAiB,GAAG,gBAAgB,CAAC;CAC1D,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG;IACvB;;;OAGG;IACH,UAAU,EAAE,MAAM,CAAC;IACnB;;;;OAIG;IACH,mBAAmB,EAAE,MAAM,CAAC;CAC/B,CAAC;AAOF;;;;;GAKG;AACH,MAAM,MAAM,aAAa,GAAG;IACxB;;OAEG;IACH,OAAO,EAAE,MAAM,CAAC;IAChB;;;OAGG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB;;;OAGG;IACH,UAAU,CAAC,EAAE,KAAK,CAAC;IACnB;;;OAGG;IACH,eAAe,CAAC,EAAE,sBAAsB,CAAC;IACzC;;;;;OAKG;IACH,YAAY,EAAE,CAAC,KAAK,EAAE,oBAAoB,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IACpE;;;;OAIG;IACH,sBAAsB,CAAC,EAAE,YAAY,CAAC;IACtC;;;;OAIG;IACH,mBAAmB,CAAC,EAAE,YAAY,CAAC;IACnC;;;;;OAKG;IACH,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B;;;;;;;OAOG;IACH,cAAc,CAAC,EAAE,CACb,KAAK,EAAE,KAAK,EACZ,KAAK,EAAE,oBAAoB,KAC1B,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;CAC7B,CAAC;AAQF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,qBAAqB,GAC9B,gBAAgB,MAAM,EACtB,SAAS,MAAM,KAChB,MAIG,CAAC;AAgPP;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,gBAAgB,GACzB,eAAe,aAAa,KAC7B,OAAO,CAAC,IAAI,CAiGd,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,iBAAiB,GAAI,eAAe,aAAa,KAAG,IAEhE,CAAC"}