@dynamic-labs/utils 0.0.0-exp20240808.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Dynamic Labs, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/_virtual/_tslib.cjs

@@ -0,0 +1,51 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+function __classPrivateFieldGet(receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+}
+
+function __classPrivateFieldSet(receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+exports.__awaiter = __awaiter;
+exports.__classPrivateFieldGet = __classPrivateFieldGet;
+exports.__classPrivateFieldSet = __classPrivateFieldSet;

package/_virtual/_tslib.js

@@ -0,0 +1,45 @@
+'use client'
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+function __classPrivateFieldGet(receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+}
+
+function __classPrivateFieldSet(receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+export { __awaiter, __classPrivateFieldGet, __classPrivateFieldSet };

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@dynamic-labs/utils",
+  "version": "0.0.0-exp20240808.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/dynamic-labs/dynamic-auth.git",
+    "directory": "packages/utils"
+  },
+  "description": "A React SDK for implementing wallet web3 authentication and authorization to your website.",
+  "bugs": {
+    "url": "https://github.com/dynamic-labs/DynamicAuth/issues"
+  },
+  "homepage": "https://github.com/dynamic-labs/DynamicAuth#readme",
+  "author": "Dynamic Labs, Inc.",
+  "license": "MIT",
+  "main": "./src/index.cjs",
+  "module": "./src/index.js",
+  "types": "./src/index.d.ts",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./src/index.d.ts",
+      "import": "./src/index.js",
+      "require": "./src/index.cjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "dependencies": {
+    "@dynamic-labs/sdk-api-core": "0.0.509",
+    "tldts": "6.0.16",
+    "@dynamic-labs/logger": "0.0.0-exp20240808.0",
+    "@dynamic-labs/types": "0.0.0-exp20240808.0",
+    "buffer": "6.0.3",
+    "stream": "0.0.2"
+  },
+  "peerDependencies": {}
+}

package/src/CancellablePromise/CancellablePromise.cjs

@@ -0,0 +1,136 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var logger = require('../logger/logger.cjs');
+
+/* eslint-disable multiline-comment-style */
+const defaultCancel = () => {
+    logger.logger.error("Tried to cancel CancellablePromise without ever assigning it's '_cancel' method");
+};
+/** An extension of Promise that allows you to explicitly cancel a promise with an external reference to it.
+ * Cancelling CancellablePromise causes it to reject with reason set to the parameter passed to the cancel method.
+ * When CancellablePromise rejects, it provides a boolean to indicate whether it was cancelled, alongside the reason.
+ *
+ * @example
+ * // Cancelling this promise
+ * const promise = new CancellablePromise(() => {}).onCancel(console.log)
+ * promise.cancel('User cancelled')
+ *
+ * // Setting up listeners for resolve, cancel and reject
+ * // (notice calling catch after onCancel prevents catch from being called by cancellation)
+ * new CancellablePromise(() => {})
+ *  .then(() => console.log('Promise resolved'))
+ *  .onCancel(() => console.log('Promise was cancelled'))
+ *  .catch(() => console.log('Promise was rejected but NOT cancelled'))
+ *
+ * // Telling whether catch was cause of cancel or not
+ * new CancellablePromise(() => {})
+ *  .then(() => console.log('Promise resolved'))
+ *  .catch(({ reason, wasCancelled }) => console.log('Promise was rejected. Cancelled: ' + wasCancelled))
+ */
+class CancellablePromise extends Promise {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    internalCancel(reason) {
+        defaultCancel();
+    }
+    constructor(executor) {
+        let superReject = defaultCancel;
+        let superResolve = () => { };
+        super((resolve, reject) => {
+            superReject = reject;
+            superResolve = resolve;
+        });
+        this.internalIsCancelled = false;
+        this.isSettled = false;
+        executor((value) => {
+            if (!this.isCancelled && !this.isSettled)
+                superResolve(value);
+            this.isSettled = true;
+        }, (reason) => {
+            if (!this.isCancelled && !this.isSettled)
+                superReject(reason);
+            this.isSettled = true;
+        });
+        this.internalCancel = superReject;
+    }
+    /** Whether this CancellablePromise was cancelled. */
+    get isCancelled() {
+        return this.internalIsCancelled;
+    }
+    /** Cancels the promise. This causes the promise to reject with { wasCancelled: true, reason: reason }
+     * where the reason is the provided argument.
+     * @returns The cancelled promise.
+     */
+    cancel(reason) {
+        if (this.isSettled)
+            return this;
+        this.internalIsCancelled = true;
+        this.internalCancel(reason);
+        this.isSettled = true;
+        return this;
+    }
+    internalOnCancel(listener, options) {
+        const newPromise = new CancellablePromise((resolve, reject) => {
+            this.internalThen(resolve, ({ wasCancelled, reason }) => {
+                if (wasCancelled)
+                    resolve(listener(reason));
+                else
+                    reject(reason);
+            }, { ignoreOnCancel: true });
+        });
+        /** Tie the new promise's cancel to this promise's cancel */
+        if (!(options === null || options === void 0 ? void 0 : options.ignoreOnCancel)) {
+            newPromise.internalOnCancel((reason) => {
+                this.cancel(reason);
+            }, { ignoreOnCancel: true });
+        }
+        return newPromise;
+    }
+    /** Allows reacting to this CancellablePromise being cancelled  */
+    onCancel(listener) {
+        return this.internalOnCancel(listener);
+    }
+    internalThen(onFulfilled, onRejected, options) {
+        /** Create a catch handler that is undefined if the received callback is undefined */
+        const catchHandler = onRejected
+            ? (reason) => onRejected({ reason, wasCancelled: this.isCancelled })
+            : onRejected;
+        // /** Create the CancellablePromise we will returned, associated to the then promise */
+        const newPromise = CancellablePromise.fromPromise(super.then(onFulfilled, catchHandler));
+        /** Tie the new promise's cancel to this promise's cancel */
+        if (!(options === null || options === void 0 ? void 0 : options.ignoreOnCancel)) {
+            newPromise.internalOnCancel((reason) => {
+                this.cancel(reason);
+            }, { ignoreOnCancel: true });
+        }
+        return newPromise;
+    }
+    then(onFulfilled, onRejected) {
+        return this.internalThen(onFulfilled, onRejected);
+    }
+    catch(onRejected) {
+        return this.then(undefined, onRejected);
+    }
+    finally(onFinally) {
+        return this.then((value) => {
+            onFinally === null || onFinally === void 0 ? void 0 : onFinally();
+            return value;
+        }, (reason) => {
+            onFinally === null || onFinally === void 0 ? void 0 : onFinally();
+            throw reason;
+        });
+    }
+    /** Generates a CancellablePromise from a Promise. If a CancellablePromise is passed, it's returned unscathed.
+     * WARNING: unless you attach a method to reject the original Promise with the "onCancel" param.
+     * cancelling the resulting CancellablePromise does NOT affect the original Promise. */
+    static fromPromise(promise) {
+        if ('internalIsCancelled' in promise)
+            return promise;
+        const newPromise = new CancellablePromise((resolve, reject) => promise.then(resolve, reject));
+        return newPromise;
+    }
+}
+
+exports.CancellablePromise = CancellablePromise;

package/src/CancellablePromise/CancellablePromise.d.ts

@@ -0,0 +1,54 @@
+type Executor<T> = (resolve: (value: T | PromiseLike<T>) => void, reject: (reason?: unknown) => void) => void;
+type CancelListener<TResult = never> = (reason?: unknown) => TResult;
+/** An extension of Promise that allows you to explicitly cancel a promise with an external reference to it.
+ * Cancelling CancellablePromise causes it to reject with reason set to the parameter passed to the cancel method.
+ * When CancellablePromise rejects, it provides a boolean to indicate whether it was cancelled, alongside the reason.
+ *
+ * @example
+ * // Cancelling this promise
+ * const promise = new CancellablePromise(() => {}).onCancel(console.log)
+ * promise.cancel('User cancelled')
+ *
+ * // Setting up listeners for resolve, cancel and reject
+ * // (notice calling catch after onCancel prevents catch from being called by cancellation)
+ * new CancellablePromise(() => {})
+ *  .then(() => console.log('Promise resolved'))
+ *  .onCancel(() => console.log('Promise was cancelled'))
+ *  .catch(() => console.log('Promise was rejected but NOT cancelled'))
+ *
+ * // Telling whether catch was cause of cancel or not
+ * new CancellablePromise(() => {})
+ *  .then(() => console.log('Promise resolved'))
+ *  .catch(({ reason, wasCancelled }) => console.log('Promise was rejected. Cancelled: ' + wasCancelled))
+ */
+export declare class CancellablePromise<T> extends Promise<T> {
+    private internalIsCancelled;
+    private isSettled;
+    private internalCancel;
+    constructor(executor: Executor<T>);
+    /** Whether this CancellablePromise was cancelled. */
+    get isCancelled(): boolean;
+    /** Cancels the promise. This causes the promise to reject with { wasCancelled: true, reason: reason }
+     * where the reason is the provided argument.
+     * @returns The cancelled promise.
+     */
+    cancel(reason?: unknown): this;
+    private internalOnCancel;
+    /** Allows reacting to this CancellablePromise being cancelled  */
+    onCancel<TResult = never>(listener: CancelListener<TResult>): CancellablePromise<T | TResult>;
+    private internalThen;
+    then<TResult1 = T, TResult2 = never>(onFulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null, onRejected?: ((reason: {
+        reason: unknown;
+        wasCancelled: boolean;
+    }) => TResult2 | PromiseLike<TResult2>) | null): CancellablePromise<TResult1 | TResult2>;
+    catch<TResult = never>(onRejected?: ((reason: {
+        reason: unknown;
+        wasCancelled: boolean;
+    }) => TResult | PromiseLike<TResult>) | null): CancellablePromise<T | TResult>;
+    finally(onFinally?: (() => void) | null): CancellablePromise<T>;
+    /** Generates a CancellablePromise from a Promise. If a CancellablePromise is passed, it's returned unscathed.
+     * WARNING: unless you attach a method to reject the original Promise with the "onCancel" param.
+     * cancelling the resulting CancellablePromise does NOT affect the original Promise. */
+    static fromPromise<T>(promise: Promise<T> | CancellablePromise<T>): CancellablePromise<T>;
+}
+export {};

package/src/CancellablePromise/CancellablePromise.js

@@ -0,0 +1,132 @@
+'use client'
+import { logger } from '../logger/logger.js';
+
+/* eslint-disable multiline-comment-style */
+const defaultCancel = () => {
+    logger.error("Tried to cancel CancellablePromise without ever assigning it's '_cancel' method");
+};
+/** An extension of Promise that allows you to explicitly cancel a promise with an external reference to it.
+ * Cancelling CancellablePromise causes it to reject with reason set to the parameter passed to the cancel method.
+ * When CancellablePromise rejects, it provides a boolean to indicate whether it was cancelled, alongside the reason.
+ *
+ * @example
+ * // Cancelling this promise
+ * const promise = new CancellablePromise(() => {}).onCancel(console.log)
+ * promise.cancel('User cancelled')
+ *
+ * // Setting up listeners for resolve, cancel and reject
+ * // (notice calling catch after onCancel prevents catch from being called by cancellation)
+ * new CancellablePromise(() => {})
+ *  .then(() => console.log('Promise resolved'))
+ *  .onCancel(() => console.log('Promise was cancelled'))
+ *  .catch(() => console.log('Promise was rejected but NOT cancelled'))
+ *
+ * // Telling whether catch was cause of cancel or not
+ * new CancellablePromise(() => {})
+ *  .then(() => console.log('Promise resolved'))
+ *  .catch(({ reason, wasCancelled }) => console.log('Promise was rejected. Cancelled: ' + wasCancelled))
+ */
+class CancellablePromise extends Promise {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    internalCancel(reason) {
+        defaultCancel();
+    }
+    constructor(executor) {
+        let superReject = defaultCancel;
+        let superResolve = () => { };
+        super((resolve, reject) => {
+            superReject = reject;
+            superResolve = resolve;
+        });
+        this.internalIsCancelled = false;
+        this.isSettled = false;
+        executor((value) => {
+            if (!this.isCancelled && !this.isSettled)
+                superResolve(value);
+            this.isSettled = true;
+        }, (reason) => {
+            if (!this.isCancelled && !this.isSettled)
+                superReject(reason);
+            this.isSettled = true;
+        });
+        this.internalCancel = superReject;
+    }
+    /** Whether this CancellablePromise was cancelled. */
+    get isCancelled() {
+        return this.internalIsCancelled;
+    }
+    /** Cancels the promise. This causes the promise to reject with { wasCancelled: true, reason: reason }
+     * where the reason is the provided argument.
+     * @returns The cancelled promise.
+     */
+    cancel(reason) {
+        if (this.isSettled)
+            return this;
+        this.internalIsCancelled = true;
+        this.internalCancel(reason);
+        this.isSettled = true;
+        return this;
+    }
+    internalOnCancel(listener, options) {
+        const newPromise = new CancellablePromise((resolve, reject) => {
+            this.internalThen(resolve, ({ wasCancelled, reason }) => {
+                if (wasCancelled)
+                    resolve(listener(reason));
+                else
+                    reject(reason);
+            }, { ignoreOnCancel: true });
+        });
+        /** Tie the new promise's cancel to this promise's cancel */
+        if (!(options === null || options === void 0 ? void 0 : options.ignoreOnCancel)) {
+            newPromise.internalOnCancel((reason) => {
+                this.cancel(reason);
+            }, { ignoreOnCancel: true });
+        }
+        return newPromise;
+    }
+    /** Allows reacting to this CancellablePromise being cancelled  */
+    onCancel(listener) {
+        return this.internalOnCancel(listener);
+    }
+    internalThen(onFulfilled, onRejected, options) {
+        /** Create a catch handler that is undefined if the received callback is undefined */
+        const catchHandler = onRejected
+            ? (reason) => onRejected({ reason, wasCancelled: this.isCancelled })
+            : onRejected;
+        // /** Create the CancellablePromise we will returned, associated to the then promise */
+        const newPromise = CancellablePromise.fromPromise(super.then(onFulfilled, catchHandler));
+        /** Tie the new promise's cancel to this promise's cancel */
+        if (!(options === null || options === void 0 ? void 0 : options.ignoreOnCancel)) {
+            newPromise.internalOnCancel((reason) => {
+                this.cancel(reason);
+            }, { ignoreOnCancel: true });
+        }
+        return newPromise;
+    }
+    then(onFulfilled, onRejected) {
+        return this.internalThen(onFulfilled, onRejected);
+    }
+    catch(onRejected) {
+        return this.then(undefined, onRejected);
+    }
+    finally(onFinally) {
+        return this.then((value) => {
+            onFinally === null || onFinally === void 0 ? void 0 : onFinally();
+            return value;
+        }, (reason) => {
+            onFinally === null || onFinally === void 0 ? void 0 : onFinally();
+            throw reason;
+        });
+    }
+    /** Generates a CancellablePromise from a Promise. If a CancellablePromise is passed, it's returned unscathed.
+     * WARNING: unless you attach a method to reject the original Promise with the "onCancel" param.
+     * cancelling the resulting CancellablePromise does NOT affect the original Promise. */
+    static fromPromise(promise) {
+        if ('internalIsCancelled' in promise)
+            return promise;
+        const newPromise = new CancellablePromise((resolve, reject) => promise.then(resolve, reject));
+        return newPromise;
+    }
+}
+
+export { CancellablePromise };

package/src/CancellablePromise/index.d.ts

@@ -0,0 +1 @@
+export { CancellablePromise } from './CancellablePromise';

package/src/DeferredPromise/DeferredPromise.cjs

@@ -0,0 +1,22 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/**
+ * A DeferredPromise provides methods to manually resolve or reject a Promise.
+ * This is useful in scenarios where you need to resolve or reject a Promise
+ * outside of the executor function.
+ *
+ * @template T The type of the value with which the promise will be resolved.
+ */
+class DeferredPromise {
+    constructor() {
+        this.promise = new Promise((resolve, reject) => {
+            this.resolve = resolve;
+            this.reject = reject;
+        });
+    }
+}
+
+exports.DeferredPromise = DeferredPromise;

package/src/DeferredPromise/DeferredPromise.d.ts

@@ -0,0 +1,13 @@
+/**
+ * A DeferredPromise provides methods to manually resolve or reject a Promise.
+ * This is useful in scenarios where you need to resolve or reject a Promise
+ * outside of the executor function.
+ *
+ * @template T The type of the value with which the promise will be resolved.
+ */
+export declare class DeferredPromise<T> {
+    promise: Promise<T>;
+    resolve: (value: T | PromiseLike<T>) => void;
+    reject: (reason?: any) => void;
+    constructor();
+}

package/src/DeferredPromise/DeferredPromise.js

@@ -0,0 +1,18 @@
+'use client'
+/**
+ * A DeferredPromise provides methods to manually resolve or reject a Promise.
+ * This is useful in scenarios where you need to resolve or reject a Promise
+ * outside of the executor function.
+ *
+ * @template T The type of the value with which the promise will be resolved.
+ */
+class DeferredPromise {
+    constructor() {
+        this.promise = new Promise((resolve, reject) => {
+            this.resolve = resolve;
+            this.reject = reject;
+        });
+    }
+}
+
+export { DeferredPromise };

package/src/DeferredPromise/index.d.ts

@@ -0,0 +1 @@
+export { DeferredPromise } from './DeferredPromise';

package/src/bufferPolyfill.cjs

@@ -0,0 +1,15 @@
+'use client'
+'use strict';
+
+var _ = require('buffer/');
+
+/* eslint-disable */
+/**
+ * This is needed for the browser to work with buffer
+ */
+if (typeof window !== 'undefined') {
+    window.global = globalThis;
+    if (!window.Buffer && typeof window.Buffer === 'undefined') {
+        Object.assign(window, { Buffer: _.Buffer });
+    }
+}

package/src/bufferPolyfill.d.ts

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

package/src/bufferPolyfill.js

@@ -0,0 +1,13 @@
+'use client'
+import { Buffer } from 'buffer/index.js';
+
+/* eslint-disable */
+/**
+ * This is needed for the browser to work with buffer
+ */
+if (typeof window !== 'undefined') {
+    window.global = globalThis;
+    if (!window.Buffer && typeof window.Buffer === 'undefined') {
+        Object.assign(window, { Buffer });
+    }
+}

package/src/bufferToBase64.cjs

@@ -0,0 +1,15 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+require('./bufferPolyfill.cjs');
+
+const bufferToBase64 = (buf) => {
+    const binstr = Array.prototype.map
+        .call(buf, (ch) => String.fromCharCode(ch))
+        .join('');
+    return Buffer.from(binstr, 'binary').toString('base64');
+};
+
+exports.bufferToBase64 = bufferToBase64;

package/src/bufferToBase64.d.ts

@@ -0,0 +1,2 @@
+import './bufferPolyfill';
+export declare const bufferToBase64: (buf: Uint8Array) => string;

package/src/bufferToBase64.js

@@ -0,0 +1,11 @@
+'use client'
+import './bufferPolyfill.js';
+
+const bufferToBase64 = (buf) => {
+    const binstr = Array.prototype.map
+        .call(buf, (ch) => String.fromCharCode(ch))
+        .join('');
+    return Buffer.from(binstr, 'binary').toString('base64');
+};
+
+export { bufferToBase64 };

package/src/ceil/ceil.cjs

@@ -0,0 +1,11 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const ceil = (value, precision = 0) => {
+    const multiplier = Math.pow(10, precision);
+    return Math.ceil(value * multiplier) / multiplier;
+};
+
+exports.ceil = ceil;

package/src/ceil/ceil.d.ts

@@ -0,0 +1 @@
+export declare const ceil: (value: number, precision?: number) => number;

package/src/ceil/ceil.js

@@ -0,0 +1,7 @@
+'use client'
+const ceil = (value, precision = 0) => {
+    const multiplier = Math.pow(10, precision);
+    return Math.ceil(value * multiplier) / multiplier;
+};
+
+export { ceil };

package/src/ceil/index.d.ts

@@ -0,0 +1 @@
+export { ceil } from './ceil';