@paimaexample/wallets 0.3.117

package/esm/events/src/utils.js

@@ -0,0 +1,93 @@
+/**
+ * Creates an MQTT path filling in specified variables in the path
+ * @param path the base MQTT path to use
+ * @param args the args to fill the path.
+ * - `undefined` (explicitly or omitted) variables will be treated as `+`
+ * - if all trailing variables are `undefined`, it will be replaced by `#`
+ */
+export function fillPath(path, args) {
+    const keys = new Set(Object.keys(args));
+    const possibleArgs = path
+        .map((p, index) => [p, index])
+        .filter(([p, _]) => typeof p === 'object')
+        .map(([_, index]) => index);
+    const filledArgsLeft = path
+        .map((p, index) => [p, index])
+        .filter(([p, _]) => typeof p === 'object' && keys.has(p.name))
+        .map(([_, index]) => index)
+        .reverse(); // reverse as pop() is more efficient than removing from the start of the array
+    let filledPath = [];
+    const addLastArg = (i) => {
+        if (i === path.length - 1) {
+            // if it's the last entry, + and # mean the same thing
+            // so we just pick +
+            filledPath.push('+');
+        }
+        else {
+            filledPath.push('#');
+        }
+    };
+    for (let i = 0; i < path.length; i++) {
+        const entry = path[i];
+        // if we've exhausted all args provided by the user
+        // but there are still args we expect later in the path
+        // ex:
+        // 1: a/{foo}/b/{bar}, user provides just `foo` and we've already processed it
+        // 2: a/{foo}, user provided nothing
+        if (filledArgsLeft.length === 0 &&
+            possibleArgs.length > 0 &&
+            i < possibleArgs[possibleArgs.length - 1]) {
+            // if we've reached at least the first argument
+            // ex: a/{foo}, we should use `a/+` instead of just `#`
+            if (i >= possibleArgs[0]) {
+                addLastArg(i);
+                break;
+            }
+        }
+        // 1) handle regular string types
+        {
+            if (typeof entry === 'string') {
+                filledPath.push(path[i]);
+                continue;
+            }
+        }
+        // 2) handle arg types
+        {
+            // handle types left undefined despite future args being specified
+            if (args[entry.name] === undefined) {
+                filledPath.push('+');
+            }
+            else {
+                // handle types explicitly provided
+                filledPath.push(args[entry.name]);
+            }
+            // if we've reached the next arg the user provided a filling for
+            if (filledArgsLeft.length > 0 && i === filledArgsLeft[filledArgsLeft.length - 1]) {
+                filledArgsLeft.pop();
+            }
+        }
+    }
+    return filledPath.join('/');
+}
+/**
+ * Convert our internal definition of an event path to an mqtt-pattern compatible path
+ * This is useful to later deconstruct topics for pattern matching
+ */
+export function toPattern(path) {
+    let result = '';
+    for (let i = 0; i < path.length; i++) {
+        const entry = path[i];
+        if (i > 0)
+            result += '/'; // fencepost problem
+        if (typeof entry === 'string') {
+            result += entry;
+        }
+        else {
+            result += `+${entry.name}`;
+        }
+    }
+    return result;
+}
+export function keysForPath(path) {
+    return path.filter(p => typeof p !== 'string').map(p => p.name);
+}

package/esm/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/esm/utils/src/binary-search.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Find the left-most entry index in an array satisfying the condition
+ *
+ * ex: binarySearch([6,7,7,8], 7, val => val) return `1`
+ */
+export declare function binarySearch<T>(arr: T[], target: number, toNum: (val: T) => number): number | undefined;
+//# sourceMappingURL=binary-search.d.ts.map

package/esm/utils/src/binary-search.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"binary-search.d.ts","sourceRoot":"","sources":["../../../src/utils/src/binary-search.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAC5B,GAAG,EAAE,CAAC,EAAE,EACR,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,CAAC,GAAG,EAAE,CAAC,KAAK,MAAM,GACxB,MAAM,GAAG,SAAS,CAmCpB"}

package/esm/utils/src/binary-search.js

@@ -0,0 +1,38 @@
+/**
+ * Find the left-most entry index in an array satisfying the condition
+ *
+ * ex: binarySearch([6,7,7,8], 7, val => val) return `1`
+ */
+export function binarySearch(arr, target, toNum) {
+    let low = 0;
+    let high = arr.length - 1;
+    let result = undefined; // This will hold the index of the smallest value >= target, if it exists
+    if (arr.length === 0) {
+        return undefined;
+    }
+    // if the target is smaller than all entries, just return right away
+    if (target - toNum(arr[0]) <= 0) {
+        return 0;
+    }
+    // if the target is bigger than all entries, just return right away
+    if (target - toNum(arr[arr.length - 1]) > 0) {
+        return undefined;
+    }
+    // first: find the largest index where the value is smaller than the target
+    while (low < high) {
+        const mid = low + Math.floor((high - low) / 2);
+        const val = target - toNum(arr[mid]);
+        if (val <= 0) {
+            high = mid;
+        }
+        else {
+            result = mid;
+            low = mid + 1;
+        }
+    }
+    // sanity check: should never happen
+    if (result == null) {
+        return undefined;
+    }
+    return result + 1;
+}

package/esm/utils/src/captcha.d.ts

@@ -0,0 +1,9 @@
+/**
+ * This method will dynamically add:
+ * <script src="https://www.google.com/recaptcha/api.js?render=YOUR_SITE_KEY"></script>
+ *
+ * You can manually add this script to your HTML,
+ * this method is just a helper to do it programmatically.
+ */
+export declare function injectReCaptchaToHTML(document: any, reCAPTCHA_site_key: string): Promise<void>;
+//# sourceMappingURL=captcha.d.ts.map

package/esm/utils/src/captcha.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"captcha.d.ts","sourceRoot":"","sources":["../../../src/utils/src/captcha.ts"],"names":[],"mappings":"AAGA;;;;;;GAMG;AACH,wBAAsB,qBAAqB,CAAC,QAAQ,EAAE,GAAG,EAAE,kBAAkB,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAUpG"}

package/esm/utils/src/captcha.js

@@ -0,0 +1,19 @@
+// <reference lib="dom" />
+// error[banned-triple-slash-directives]: triple slash directives that modify globals are not allowed
+/**
+ * This method will dynamically add:
+ * <script src="https://www.google.com/recaptcha/api.js?render=YOUR_SITE_KEY"></script>
+ *
+ * You can manually add this script to your HTML,
+ * this method is just a helper to do it programmatically.
+ */
+export async function injectReCaptchaToHTML(document, reCAPTCHA_site_key) {
+    const url = `https://www.google.com/recaptcha/api.js?render=${reCAPTCHA_site_key}`;
+    return await new Promise((resolve, reject) => {
+        const el = document.createElement("script");
+        el.src = url;
+        el.addEventListener("load", () => resolve());
+        el.addEventListener("error", () => reject());
+        document.body.append(el);
+    });
+}

package/esm/utils/src/concurrency/condVar.d.ts

@@ -0,0 +1,25 @@
+import type { Operation } from "effection";
+export type CondVar<T> = {
+    wait: () => Operation<T>;
+    wake: (val: T) => void;
+};
+/**
+ * Allows blocking execution until a specific wake is called
+ *
+ * @example
+ * ```javascript
+ * const { wait, wake } = conditionVariable<void>();
+ * yield* spawn(function*() {
+ *     console.log('start wait');
+ *     yield* wait();
+ *     console.log('done wait');
+ * });
+ *
+ * yield* sleep(1000);
+ * wait(); // allows the spawn to continue executing
+ * ```
+ *
+ * See [Condition variables](https://en.wikipedia.org/wiki/Monitor_%28synchronization%29#Condition_variables) for more information
+ */
+export declare function conditionVariable<T>(): CondVar<T>;
+//# sourceMappingURL=condVar.d.ts.map

package/esm/utils/src/concurrency/condVar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"condVar.d.ts","sourceRoot":"","sources":["../../../../src/utils/src/concurrency/condVar.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAwB,MAAM,WAAW,CAAC;AAGjE,MAAM,MAAM,OAAO,CAAC,CAAC,IAAI;IACvB,IAAI,EAAE,MAAM,SAAS,CAAC,CAAC,CAAC,CAAC;IACzB,IAAI,EAAE,CAAC,GAAG,EAAE,CAAC,KAAK,IAAI,CAAC;CACxB,CAAC;AAEF;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,CAyBjD"}

package/esm/utils/src/concurrency/condVar.js

@@ -0,0 +1,39 @@
+import { action, useScope } from "effection";
+/**
+ * Allows blocking execution until a specific wake is called
+ *
+ * @example
+ * ```javascript
+ * const { wait, wake } = conditionVariable<void>();
+ * yield* spawn(function*() {
+ *     console.log('start wait');
+ *     yield* wait();
+ *     console.log('done wait');
+ * });
+ *
+ * yield* sleep(1000);
+ * wait(); // allows the spawn to continue executing
+ * ```
+ *
+ * See [Condition variables](https://en.wikipedia.org/wiki/Monitor_%28synchronization%29#Condition_variables) for more information
+ */
+export function conditionVariable() {
+    let continuations = [];
+    const wait = function* () {
+        const scope = yield* useScope();
+        return yield* action(function* (resolve, _reject) {
+            continuations.push({ resolve, scope });
+        });
+    };
+    const wake = (val) => {
+        const oldVal = continuations;
+        continuations = [];
+        for (const continuation of oldVal) {
+            // note: we explicitly do not await here
+            void continuation.scope.run(function* () {
+                continuation.resolve(val);
+            });
+        }
+    };
+    return { wait, wake };
+}

package/esm/utils/src/concurrency/latch.d.ts

@@ -0,0 +1,25 @@
+import type { Operation } from "effection";
+/**
+ * Allow blocking execution until counted down N times
+ *
+ * @example
+ * ```javascript
+ * const { wait, countDown } = countdownLatch(2);
+ * yield* spawn(function* () {
+ *   yield* wait();
+ *   console.log("done");
+ * });
+ *
+ * yield* sleep(1000);
+ * countDown();
+ * yield* sleep(1000);
+ * countDown();
+ * ```
+ *
+ * See [Barrier](https://en.wikipedia.org/wiki/Barrier_%28computer_science%29) for more information
+ */
+export declare function countdownLatch<T>(count: number): {
+    wait: (timeout?: number) => Operation<void>;
+    countDown: () => void;
+};
+//# sourceMappingURL=latch.d.ts.map

package/esm/utils/src/concurrency/latch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"latch.d.ts","sourceRoot":"","sources":["../../../../src/utils/src/concurrency/latch.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAI3C;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAC9B,KAAK,EAAE,MAAM,GACZ;IACD,IAAI,EAAE,CAAC,OAAO,CAAC,EAAE,MAAM,KAAK,SAAS,CAAC,IAAI,CAAC,CAAC;IAC5C,SAAS,EAAE,MAAM,IAAI,CAAC;CACvB,CAgCA"}

package/esm/utils/src/concurrency/latch.js

@@ -0,0 +1,51 @@
+import { action, race, sleep, spawn } from "effection";
+import { conditionVariable } from "./condVar.js";
+/**
+ * Allow blocking execution until counted down N times
+ *
+ * @example
+ * ```javascript
+ * const { wait, countDown } = countdownLatch(2);
+ * yield* spawn(function* () {
+ *   yield* wait();
+ *   console.log("done");
+ * });
+ *
+ * yield* sleep(1000);
+ * countDown();
+ * yield* sleep(1000);
+ * countDown();
+ * ```
+ *
+ * See [Barrier](https://en.wikipedia.org/wiki/Barrier_%28computer_science%29) for more information
+ */
+export function countdownLatch(count) {
+    const vars = new Array(count).fill(null).map(() => conditionVariable());
+    let currIndex = 0;
+    const wait = (timeout) => action(function* (resolve, reject) {
+        // note: start at `currIndex` and not 0
+        //       this is to support waiting on latches that have already started
+        const waitAll = yield* spawn(function* () {
+            for (let i = currIndex; i < count; i++) {
+                yield* vars[i].wait();
+            }
+            resolve();
+        });
+        if (timeout == null)
+            return yield* waitAll;
+        const rejectOnTimeout = yield* spawn(function* () {
+            yield* sleep(timeout);
+            reject(new Error("timeout"));
+        });
+        yield* race([waitAll, rejectOnTimeout]);
+    });
+    const countDown = () => {
+        if (currIndex >= count) {
+            return;
+        }
+        const oldValue = currIndex;
+        currIndex++;
+        vars[oldValue].wake();
+    };
+    return { wait, countDown };
+}

package/esm/utils/src/concurrency/mod.d.ts

@@ -0,0 +1,5 @@
+export * from "./condVar.js";
+export * from "./latch.js";
+export * from "./retry.js";
+export * from "./utils.js";
+//# sourceMappingURL=mod.d.ts.map

package/esm/utils/src/concurrency/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../../../src/utils/src/concurrency/mod.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC"}

package/esm/utils/src/concurrency/mod.js

@@ -0,0 +1,4 @@
+export * from "./condVar.js";
+export * from "./latch.js";
+export * from "./retry.js";
+export * from "./utils.js";

package/esm/utils/src/concurrency/retry.d.ts

@@ -0,0 +1,14 @@
+import type { Operation } from "effection";
+export declare function retry<Success, Failure = Success>(fn: () => Operation<Success | Failure>, isSuccess: (result: Success | Failure) => boolean, onRetry?: (failResult: Failure) => Operation<void>, maxAttempts?: number): Operation<Success>;
+type Success<T> = {
+    data: T;
+    error: null;
+};
+type Failure<E> = {
+    data: null;
+    error: E;
+};
+type Result<T, E = Error> = Success<T> | Failure<E>;
+export declare function tryYield<T, E = Error>(promise: Operation<T>): Operation<Result<T, E>>;
+export {};
+//# sourceMappingURL=retry.d.ts.map

package/esm/utils/src/concurrency/retry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"retry.d.ts","sourceRoot":"","sources":["../../../../src/utils/src/concurrency/retry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAE3C,wBAAiB,KAAK,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,EAC/C,EAAE,EAAE,MAAM,SAAS,CAAC,OAAO,GAAG,OAAO,CAAC,EACtC,SAAS,EAAE,CAAC,MAAM,EAAE,OAAO,GAAG,OAAO,KAAK,OAAO,EACjD,OAAO,CAAC,EAAE,CAAC,UAAU,EAAE,OAAO,KAAK,SAAS,CAAC,IAAI,CAAC,EAClD,WAAW,CAAC,EAAE,MAAM,GACnB,SAAS,CAAC,OAAO,CAAC,CAQpB;AA6BD,KAAK,OAAO,CAAC,CAAC,IAAI;IAChB,IAAI,EAAE,CAAC,CAAC;IACR,KAAK,EAAE,IAAI,CAAC;CACb,CAAC;AAEF,KAAK,OAAO,CAAC,CAAC,IAAI;IAChB,IAAI,EAAE,IAAI,CAAC;IACX,KAAK,EAAE,CAAC,CAAC;CACV,CAAC;AAEF,KAAK,MAAM,CAAC,CAAC,EAAE,CAAC,GAAG,KAAK,IAAI,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;AAGpD,wBAAiB,QAAQ,CAAC,CAAC,EAAE,CAAC,GAAG,KAAK,EACpC,OAAO,EAAE,SAAS,CAAC,CAAC,CAAC,GACpB,SAAS,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAOzB"}

package/esm/utils/src/concurrency/retry.js

@@ -0,0 +1,26 @@
+export function* retry(fn, isSuccess, onRetry, maxAttempts) {
+    return yield* retryInternal(fn, isSuccess, 0, onRetry, maxAttempts);
+}
+function* retryInternal(fn, isSuccess, currAttempt, onRetry, maxAttempts) {
+    const result = yield* fn();
+    if (isSuccess(result)) {
+        return result;
+    }
+    if (onRetry != null) {
+        yield* onRetry(result);
+    }
+    if (maxAttempts == null || currAttempt !== maxAttempts) {
+        return yield* retryInternal(fn, isSuccess, currAttempt + 1, onRetry, maxAttempts);
+    }
+    throw new Error("Max attempts reached");
+}
+// Main wrapper function
+export function* tryYield(promise) {
+    try {
+        const data = yield* promise;
+        return { data, error: null };
+    }
+    catch (error) {
+        return { data: null, error: error };
+    }
+}

package/esm/utils/src/concurrency/utils.d.ts

@@ -0,0 +1,27 @@
+import type { Operation } from "effection";
+/**
+ * Equivalent of Promise.then
+ */
+export declare function then<A, B>(operation: Operation<A>, fn: (value: A) => Operation<B>): Operation<B>;
+/**
+ * TODO: this is a better `then` since it's much easier to chain
+ * @example
+export function then<A, B>(
+  fn: (value: A) => Operation<B>,
+): (operation: Operation<A>) => Operation<B> {
+  return function* (operation) {
+    return yield* fn(yield* operation);
+  };
+}
+  * but the problem is that it relies on a `pipe` function
+  * that is only available in effection v4
+  * end-goal: api looks like this
+  * @example
+pipe(
+  operation,
+  then(lift((val) => val * 2)),
+  then(lift((val) => String(val)),
+  then(lift((val) => val.toUpperCase())),
+)
+*/
+//# sourceMappingURL=utils.d.ts.map

package/esm/utils/src/concurrency/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../src/utils/src/concurrency/utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAE3C;;GAEG;AACH,wBAAiB,IAAI,CAAC,CAAC,EAAE,CAAC,EACxB,SAAS,EAAE,SAAS,CAAC,CAAC,CAAC,EACvB,EAAE,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,SAAS,CAAC,CAAC,CAAC,GAC7B,SAAS,CAAC,CAAC,CAAC,CAEd;AAED;;;;;;;;;;;;;;;;;;;;EAoBE"}

package/esm/utils/src/concurrency/utils.js

@@ -0,0 +1,27 @@
+/**
+ * Equivalent of Promise.then
+ */
+export function* then(operation, fn) {
+    return yield* fn(yield* operation);
+}
+/**
+ * TODO: this is a better `then` since it's much easier to chain
+ * @example
+export function then<A, B>(
+  fn: (value: A) => Operation<B>,
+): (operation: Operation<A>) => Operation<B> {
+  return function* (operation) {
+    return yield* fn(yield* operation);
+  };
+}
+  * but the problem is that it relies on a `pipe` function
+  * that is only available in effection v4
+  * end-goal: api looks like this
+  * @example
+pipe(
+  operation,
+  then(lift((val) => val * 2)),
+  then(lift((val) => String(val)),
+  then(lift((val) => val.toUpperCase())),
+)
+*/

package/esm/utils/src/constants.d.ts

@@ -0,0 +1,4 @@
+export declare const DYNAMIC_PRIMITIVE_NAME_SEPARATOR = "##";
+export declare function generateDynamicPrimitivePrefix(parentName: string): string;
+export declare function generateDynamicPrimitiveName(parentName: string, id: number): string;
+//# sourceMappingURL=constants.d.ts.map

package/esm/utils/src/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../src/utils/src/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,gCAAgC,OAAO,CAAC;AACrD,wBAAgB,8BAA8B,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAEzE;AACD,wBAAgB,4BAA4B,CAC1C,UAAU,EAAE,MAAM,EAClB,EAAE,EAAE,MAAM,GACT,MAAM,CAER"}

package/esm/utils/src/constants.js

@@ -0,0 +1,7 @@
+export const DYNAMIC_PRIMITIVE_NAME_SEPARATOR = "##";
+export function generateDynamicPrimitivePrefix(parentName) {
+    return `${parentName}${DYNAMIC_PRIMITIVE_NAME_SEPARATOR}`;
+}
+export function generateDynamicPrimitiveName(parentName, id) {
+    return `${generateDynamicPrimitivePrefix(parentName)}${id}`;
+}

package/esm/utils/src/decorators/bound.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Avoids member functions having the wrong `this` value when passed as a function pointer.\
+ * AKA shortcut for `this.func.bind(this)`
+ *
+ * Taken form https://www.typescriptlang.org/docs/handbook/release-notes/typescript-5-0.html
+ *
+ * Careful: this can cause a segmentation fault on Deno (https://github.com/denoland/deno/issues/25192)
+ */
+export declare function bound(_originalMethod: any, context: ClassMethodDecoratorContext<Record<string | symbol, any>>): void;
+//# sourceMappingURL=bound.d.ts.map

package/esm/utils/src/decorators/bound.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bound.d.ts","sourceRoot":"","sources":["../../../../src/utils/src/decorators/bound.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,wBAAgB,KAAK,CACnB,eAAe,EAAE,GAAG,EACpB,OAAO,EAAE,2BAA2B,CAAC,MAAM,CAAC,MAAM,GAAG,MAAM,EAAE,GAAG,CAAC,CAAC,QAWnE"}

package/esm/utils/src/decorators/bound.js

@@ -0,0 +1,17 @@
+/**
+ * Avoids member functions having the wrong `this` value when passed as a function pointer.\
+ * AKA shortcut for `this.func.bind(this)`
+ *
+ * Taken form https://www.typescriptlang.org/docs/handbook/release-notes/typescript-5-0.html
+ *
+ * Careful: this can cause a segmentation fault on Deno (https://github.com/denoland/deno/issues/25192)
+ */
+export function bound(_originalMethod, context) {
+    const methodName = context.name;
+    if (context.private) {
+        throw new Error(`'bound' cannot decorate private properties like ${methodName}.`);
+    }
+    context.addInitializer(function () {
+        this[methodName] = this[methodName].bind(this);
+    });
+}

package/esm/utils/src/decorators/mod.d.ts

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

package/esm/utils/src/decorators/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../../../src/utils/src/decorators/mod.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC"}

package/esm/utils/src/decorators/mod.js

@@ -0,0 +1 @@
+export * from "./bound.js";

package/esm/utils/src/mod.d.ts

@@ -0,0 +1,8 @@
+export * from "./types/mod.js";
+export * from "./constants.js";
+export * from "./viem.js";
+export * from "./captcha.js";
+export * from "./binary-search.js";
+export * from "./concurrency/mod.js";
+export * from "./decorators/mod.js";
+//# sourceMappingURL=mod.d.ts.map

package/esm/utils/src/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../../src/utils/src/mod.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,WAAW,CAAC;AAC1B,cAAc,cAAc,CAAC;AAC7B,cAAc,oBAAoB,CAAC;AACnC,cAAc,sBAAsB,CAAC;AACrC,cAAc,qBAAqB,CAAC"}

package/esm/utils/src/mod.js

@@ -0,0 +1,7 @@
+export * from "./types/mod.js";
+export * from "./constants.js";
+export * from "./viem.js";
+export * from "./captcha.js";
+export * from "./binary-search.js";
+export * from "./concurrency/mod.js";
+export * from "./decorators/mod.js";

package/esm/utils/src/types/json-query.d.ts

@@ -0,0 +1,30 @@
+export type ErrorCode = number;
+export type ErrorMessageMapping = Record<ErrorCode, string>;
+export type ErrorMessageFxn = (errorCode: ErrorCode) => string;
+export interface SuccessfulResultMessage {
+    success: true;
+    message: string;
+}
+export interface SuccessfulResult<T> {
+    success: true;
+    result: T;
+}
+export interface FailedResult {
+    success: false;
+    errorMessage: string;
+    errorCode?: number;
+}
+export type Result<T> = SuccessfulResult<T> | FailedResult;
+export type InternalServerErrorResult = FailedResult;
+/** comes from the `tsoa` package, but we don't want it as a dependency just for this type  */
+export interface FieldErrors {
+    [name: string]: {
+        message: string;
+        value?: any;
+    };
+}
+export interface ValidateErrorResult {
+    message: "Validation Failed";
+    details?: FieldErrors;
+}
+//# sourceMappingURL=json-query.d.ts.map

package/esm/utils/src/types/json-query.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json-query.d.ts","sourceRoot":"","sources":["../../../../src/utils/src/types/json-query.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,SAAS,GAAG,MAAM,CAAC;AAC/B,MAAM,MAAM,mBAAmB,GAAG,MAAM,CAAC,SAAS,EAAE,MAAM,CAAC,CAAC;AAE5D,MAAM,MAAM,eAAe,GAAG,CAAC,SAAS,EAAE,SAAS,KAAK,MAAM,CAAC;AAE/D,MAAM,WAAW,uBAAuB;IACtC,OAAO,EAAE,IAAI,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,gBAAgB,CAAC,CAAC;IACjC,OAAO,EAAE,IAAI,CAAC;IACd,MAAM,EAAE,CAAC,CAAC;CACX;AAED,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,KAAK,CAAC;IACf,YAAY,EAAE,MAAM,CAAC;IACrB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,MAAM,MAAM,CAAC,CAAC,IAAI,gBAAgB,CAAC,CAAC,CAAC,GAAG,YAAY,CAAC;AAE3D,MAAM,MAAM,yBAAyB,GAAG,YAAY,CAAC;AAErD,8FAA8F;AAC9F,MAAM,WAAW,WAAW;IAC1B,CAAC,IAAI,EAAE,MAAM,GAAG;QACd,OAAO,EAAE,MAAM,CAAC;QAChB,KAAK,CAAC,EAAE,GAAG,CAAC;KACb,CAAC;CACH;AACD,MAAM,WAAW,mBAAmB;IAClC,OAAO,EAAE,mBAAmB,CAAC;IAC7B,OAAO,CAAC,EAAE,WAAW,CAAC;CACvB"}

package/esm/utils/src/types/json-query.js

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