@semaphore-protocol/utils 4.0.0-beta

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Ethereum Foundation
+
+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/README.md

@@ -0,0 +1,79 @@
+<p align="center">
+    <h1 align="center">
+        Semaphore utils
+    </h1>
+    <p align="center">A library to provide utility functions to the other Semaphore packages.</p>
+</p>
+
+<p align="center">
+    <a href="https://github.com/semaphore-protocol">
+        <img src="https://img.shields.io/badge/project-Semaphore-blue.svg?style=flat-square">
+    </a>
+    <a href="https://github.com/semaphore-protocol/semaphore/blob/main/LICENSE">
+        <img alt="NPM license" src="https://img.shields.io/npm/l/%40semaphore-protocol%2Futils?style=flat-square">
+    </a>
+    <a href="https://www.npmjs.com/package/@semaphore-protocol/utils">
+        <img alt="NPM version" src="https://img.shields.io/npm/v/@semaphore-protocol/utils?style=flat-square" />
+    </a>
+    <a href="https://npmjs.org/package/@semaphore-protocol/utils">
+        <img alt="Downloads" src="https://img.shields.io/npm/dm/@semaphore-protocol/utils.svg?style=flat-square" />
+    </a>
+    <a href="https://js.semaphore.pse.dev/modules/_semaphore_protocol_utils">
+        <img alt="Documentation typedoc" src="https://img.shields.io/badge/docs-typedoc-744C7C?style=flat-square">
+    </a>
+    <a href="https://eslint.org/">
+        <img alt="Linter eslint" src="https://img.shields.io/badge/linter-eslint-8080f2?style=flat-square&logo=eslint" />
+    </a>
+    <a href="https://prettier.io/">
+        <img alt="Code style prettier" src="https://img.shields.io/badge/code%20style-prettier-f8bc45?style=flat-square&logo=prettier" />
+    </a>
+</p>
+
+<div align="center">
+    <h4>
+        <a href="https://github.com/semaphore-protocol/semaphore/blob/main/CONTRIBUTING.md">
+            👥 Contributing
+        </a>
+        <span>&nbsp;&nbsp;|&nbsp;&nbsp;</span>
+        <a href="https://github.com/semaphore-protocol/semaphore/blob/main/CODE_OF_CONDUCT.md">
+            🤝 Code of conduct
+        </a>
+        <span>&nbsp;&nbsp;|&nbsp;&nbsp;</span>
+        <a href="https://github.com/semaphore-protocol/semaphore/contribute">
+            🔎 Issues
+        </a>
+        <span>&nbsp;&nbsp;|&nbsp;&nbsp;</span>
+        <a href="https://semaphore.pse.dev/discord">
+            🗣️ Chat &amp; Support
+        </a>
+    </h4>
+</div>
+
+## 🛠 Install
+
+### npm or yarn
+
+Install the `@semaphore-protocol/utils` package with npm:
+
+```bash
+npm i @semaphore-protocol/utils
+```
+
+or yarn:
+
+```bash
+yarn add @semaphore-protocol/utils
+```
+
+## 📜 Usage
+
+For more information on the functions and modules provided by `@semaphore-protocol/utils`, please refer to the [TypeDoc documentation](https://js.semaphore.pse.dev/modules/_semaphore_protocol_utils).
+
+```typescript
+// You can import modules from the main bundle.
+import { errors, types } from "@semaphore-protocol/utils"
+
+// Or by using conditional exports.
+import { requireNumber } from "@semaphore-protocol/utils/errors"
+import { isNumber } from "@semaphore-protocol/utils/types"
+```

package/dist/index.cjs

@@ -0,0 +1,259 @@
+/**
+ * @module @semaphore-protocol/utils
+ * @version 4.0.0-beta
+ * @file A library to provide utility functions to the other Semaphore packages.
+ * @copyright Ethereum Foundation 2024
+ * @license MIT
+ * @see [Github]{@link https://github.com/semaphore-protocol/semaphore/tree/main/packages/utils}
+*/
+'use strict';
+
+/**
+ * @module Types
+ * This module provides utility functions to check data types.
+ * It defines a set of supported types and includes functions to check if
+ * a value is defined and if it matches a supported type. These functions
+ * are useful for type checking and validation in the other libraries,
+ * enhancing code robustness and reliability.
+ */
+// The list of types supported by this utility functions.
+var supportedTypes = ["number", "string", "function", "array", "uint8array", "object", "bigint"];
+/**
+ * It returns true if the value is defined, false otherwise.
+ * @param value The value to be checked.
+ * @returns True or false.
+ */
+function isDefined(value) {
+    return typeof value !== "undefined";
+}
+/**
+ * It returns true if the value is a number, false otherwise.
+ * @param value The value to be checked.
+ * @returns True or false.
+ */
+function isNumber(value) {
+    return typeof value === "number";
+}
+/**
+ * It returns true if the value is a string, false otherwise.
+ * @param value The value to be checked.
+ * @returns True or false.
+ */
+function isString(value) {
+    return typeof value === "string";
+}
+/**
+ * It returns true if the value is a function, false otherwise.
+ * @param value The value to be checked.
+ * @returns True or false.
+ */
+function isFunction(value) {
+    return typeof value === "function";
+}
+/**
+ * It returns true if the value is an array, false otherwise.
+ * @param value The value to be checked.
+ * @returns True or false.
+ */
+function isArray(value) {
+    return typeof value === "object" && Array.isArray(value);
+}
+/**
+ * It returns true if the value is a uint8array, false otherwise.
+ * @param value The value to be checked.
+ * @returns True or false.
+ */
+function isUint8Array(value) {
+    return value instanceof Uint8Array;
+}
+/**
+ * It returns true if the value is an object, false otherwise.
+ * @param value The value to be checked.
+ * @returns True or false.
+ */
+function isObject(value) {
+    return typeof value === "object";
+}
+/**
+ * It returns true if the value is a bigint, false otherwise.
+ * @param value The value to be checked.
+ * @returns True or false.
+ */
+function isBigInt(value) {
+    return typeof value === "bigint";
+}
+/**
+ * It returns true if the value type is the same as the type passed
+ * as the second parameter, false otherwise.
+ * @param type The expected type.
+ * @returns True or false.
+ */
+function isType(value, type) {
+    switch (type) {
+        case "number":
+            return isNumber(value);
+        case "string":
+            return isString(value);
+        case "function":
+            return isFunction(value);
+        case "array":
+            return isArray(value);
+        case "uint8array":
+            return isUint8Array(value);
+        case "object":
+            return isObject(value);
+        case "bigint":
+            return isBigInt(value);
+        default:
+            return false;
+    }
+}
+/**
+ * Return true if the type is being supported by this utility
+ * functions, false otherwise.
+ * @param type The type to be checked.
+ * @returns True or false
+ */
+function isSupportedType(type) {
+    return supportedTypes.includes(type);
+}
+
+var types = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    isArray: isArray,
+    isBigInt: isBigInt,
+    isDefined: isDefined,
+    isFunction: isFunction,
+    isNumber: isNumber,
+    isObject: isObject,
+    isString: isString,
+    isSupportedType: isSupportedType,
+    isType: isType,
+    isUint8Array: isUint8Array
+});
+
+/**
+ * @module Errors
+ * This module is designed to provide utility functions for validating
+ * function parameters. It includes functions that throw type errors if
+ * the parameters do not meet specified criteria, such as being defined,
+ * a number, a string, a function, or an array. This module helps ensure
+ * that functions receive the correct types of inputs, enhancing code
+ * reliability and reducing runtime errors.
+ */
+/**
+ * It throws a type error if the parameter value has not been defined.
+ * @param parameterValue The parameter value.
+ * @param parameterName The parameter name.
+ */
+function requireDefined(parameterValue, parameterName) {
+    if (!isDefined(parameterValue)) {
+        throw new TypeError("Parameter '".concat(parameterName, "' is not defined"));
+    }
+}
+/**
+ * It throws a type error if the parameter value is not a number.
+ * @param parameterValue The parameter value.
+ * @param parameterName The parameter name.
+ */
+function requireNumber(parameterValue, parameterName) {
+    if (!isNumber(parameterValue)) {
+        throw new TypeError("Parameter '".concat(parameterName, "' is not a number"));
+    }
+}
+/**
+ * It throws a type error if the parameter value is not a string.
+ * @param parameterValue The parameter value.
+ * @param parameterName The parameter name.
+ */
+function requireString(parameterValue, parameterName) {
+    if (!isString(parameterValue)) {
+        throw new TypeError("Parameter '".concat(parameterName, "' is not a string"));
+    }
+}
+/**
+ * It throws a type error if the parameter value is not a function.
+ * @param parameterValue The parameter value.
+ * @param parameterName The parameter name.
+ */
+function requireFunction(parameterValue, parameterName) {
+    if (!isFunction(parameterValue)) {
+        throw new TypeError("Parameter '".concat(parameterName, "' is not a function"));
+    }
+}
+/**
+ * It throws a type error if the parameter value is not an array.
+ * @param parameterValue The parameter value.
+ * @param parameterName The parameter name.
+ */
+function requireArray(parameterValue, parameterName) {
+    if (!isArray(parameterValue)) {
+        throw new TypeError("Parameter '".concat(parameterName, "' is not an array"));
+    }
+}
+/**
+ * It throws a type error if the parameter value is not a uint8array.
+ * @param parameterValue The parameter value.
+ * @param parameterName The parameter name.
+ */
+function requireUint8Array(parameterValue, parameterName) {
+    if (!isUint8Array(parameterValue)) {
+        throw new TypeError("Parameter '".concat(parameterName, "' is not a Uint8Array"));
+    }
+}
+/**
+ * It throws a type error if the parameter value is not an object.
+ * @param parameterValue The parameter value.
+ * @param parameterName The parameter name.
+ */
+function requireObject(parameterValue, parameterName) {
+    if (!isObject(parameterValue)) {
+        throw new TypeError("Parameter '".concat(parameterName, "' is not an object"));
+    }
+}
+/**
+ * It throws a type error if the parameter value is not a bigint.
+ * @param parameterValue The parameter value.
+ * @param parameterName The parameter name.
+ */
+function requireBigInt(parameterValue, parameterName) {
+    if (!isBigInt(parameterValue)) {
+        throw new TypeError("Parameter '".concat(parameterName, "' is not a bigint"));
+    }
+}
+/**
+ * It throws a type error if the parameter value type is not part of the list of types.
+ * @param parameterValue The parameter value.
+ * @param parameterName The parameter name.
+ */
+function requireTypes(parameterValue, parameterName, types) {
+    for (var _i = 0, types_1 = types; _i < types_1.length; _i++) {
+        var type = types_1[_i];
+        if (!isSupportedType(type)) {
+            throw new Error("Type '".concat(type, "' is not supported"));
+        }
+    }
+    for (var _a = 0, types_2 = types; _a < types_2.length; _a++) {
+        var type = types_2[_a];
+        if (isType(parameterValue, type)) {
+            return;
+        }
+    }
+    throw new TypeError("Parameter '".concat(parameterName, "' is none of the following types: ").concat(types.join(", ")));
+}
+
+var errors = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    requireArray: requireArray,
+    requireBigInt: requireBigInt,
+    requireDefined: requireDefined,
+    requireFunction: requireFunction,
+    requireNumber: requireNumber,
+    requireObject: requireObject,
+    requireString: requireString,
+    requireTypes: requireTypes,
+    requireUint8Array: requireUint8Array
+});
+
+exports.errors = errors;
+exports.types = types;

package/dist/index.js

@@ -0,0 +1,256 @@
+/**
+ * @module @semaphore-protocol/utils
+ * @version 4.0.0-beta
+ * @file A library to provide utility functions to the other Semaphore packages.
+ * @copyright Ethereum Foundation 2024
+ * @license MIT
+ * @see [Github]{@link https://github.com/semaphore-protocol/semaphore/tree/main/packages/utils}
+*/
+/**
+ * @module Types
+ * This module provides utility functions to check data types.
+ * It defines a set of supported types and includes functions to check if
+ * a value is defined and if it matches a supported type. These functions
+ * are useful for type checking and validation in the other libraries,
+ * enhancing code robustness and reliability.
+ */
+// The list of types supported by this utility functions.
+var supportedTypes = ["number", "string", "function", "array", "uint8array", "object", "bigint"];
+/**
+ * It returns true if the value is defined, false otherwise.
+ * @param value The value to be checked.
+ * @returns True or false.
+ */
+function isDefined(value) {
+    return typeof value !== "undefined";
+}
+/**
+ * It returns true if the value is a number, false otherwise.
+ * @param value The value to be checked.
+ * @returns True or false.
+ */
+function isNumber(value) {
+    return typeof value === "number";
+}
+/**
+ * It returns true if the value is a string, false otherwise.
+ * @param value The value to be checked.
+ * @returns True or false.
+ */
+function isString(value) {
+    return typeof value === "string";
+}
+/**
+ * It returns true if the value is a function, false otherwise.
+ * @param value The value to be checked.
+ * @returns True or false.
+ */
+function isFunction(value) {
+    return typeof value === "function";
+}
+/**
+ * It returns true if the value is an array, false otherwise.
+ * @param value The value to be checked.
+ * @returns True or false.
+ */
+function isArray(value) {
+    return typeof value === "object" && Array.isArray(value);
+}
+/**
+ * It returns true if the value is a uint8array, false otherwise.
+ * @param value The value to be checked.
+ * @returns True or false.
+ */
+function isUint8Array(value) {
+    return value instanceof Uint8Array;
+}
+/**
+ * It returns true if the value is an object, false otherwise.
+ * @param value The value to be checked.
+ * @returns True or false.
+ */
+function isObject(value) {
+    return typeof value === "object";
+}
+/**
+ * It returns true if the value is a bigint, false otherwise.
+ * @param value The value to be checked.
+ * @returns True or false.
+ */
+function isBigInt(value) {
+    return typeof value === "bigint";
+}
+/**
+ * It returns true if the value type is the same as the type passed
+ * as the second parameter, false otherwise.
+ * @param type The expected type.
+ * @returns True or false.
+ */
+function isType(value, type) {
+    switch (type) {
+        case "number":
+            return isNumber(value);
+        case "string":
+            return isString(value);
+        case "function":
+            return isFunction(value);
+        case "array":
+            return isArray(value);
+        case "uint8array":
+            return isUint8Array(value);
+        case "object":
+            return isObject(value);
+        case "bigint":
+            return isBigInt(value);
+        default:
+            return false;
+    }
+}
+/**
+ * Return true if the type is being supported by this utility
+ * functions, false otherwise.
+ * @param type The type to be checked.
+ * @returns True or false
+ */
+function isSupportedType(type) {
+    return supportedTypes.includes(type);
+}
+
+var types = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    isArray: isArray,
+    isBigInt: isBigInt,
+    isDefined: isDefined,
+    isFunction: isFunction,
+    isNumber: isNumber,
+    isObject: isObject,
+    isString: isString,
+    isSupportedType: isSupportedType,
+    isType: isType,
+    isUint8Array: isUint8Array
+});
+
+/**
+ * @module Errors
+ * This module is designed to provide utility functions for validating
+ * function parameters. It includes functions that throw type errors if
+ * the parameters do not meet specified criteria, such as being defined,
+ * a number, a string, a function, or an array. This module helps ensure
+ * that functions receive the correct types of inputs, enhancing code
+ * reliability and reducing runtime errors.
+ */
+/**
+ * It throws a type error if the parameter value has not been defined.
+ * @param parameterValue The parameter value.
+ * @param parameterName The parameter name.
+ */
+function requireDefined(parameterValue, parameterName) {
+    if (!isDefined(parameterValue)) {
+        throw new TypeError("Parameter '".concat(parameterName, "' is not defined"));
+    }
+}
+/**
+ * It throws a type error if the parameter value is not a number.
+ * @param parameterValue The parameter value.
+ * @param parameterName The parameter name.
+ */
+function requireNumber(parameterValue, parameterName) {
+    if (!isNumber(parameterValue)) {
+        throw new TypeError("Parameter '".concat(parameterName, "' is not a number"));
+    }
+}
+/**
+ * It throws a type error if the parameter value is not a string.
+ * @param parameterValue The parameter value.
+ * @param parameterName The parameter name.
+ */
+function requireString(parameterValue, parameterName) {
+    if (!isString(parameterValue)) {
+        throw new TypeError("Parameter '".concat(parameterName, "' is not a string"));
+    }
+}
+/**
+ * It throws a type error if the parameter value is not a function.
+ * @param parameterValue The parameter value.
+ * @param parameterName The parameter name.
+ */
+function requireFunction(parameterValue, parameterName) {
+    if (!isFunction(parameterValue)) {
+        throw new TypeError("Parameter '".concat(parameterName, "' is not a function"));
+    }
+}
+/**
+ * It throws a type error if the parameter value is not an array.
+ * @param parameterValue The parameter value.
+ * @param parameterName The parameter name.
+ */
+function requireArray(parameterValue, parameterName) {
+    if (!isArray(parameterValue)) {
+        throw new TypeError("Parameter '".concat(parameterName, "' is not an array"));
+    }
+}
+/**
+ * It throws a type error if the parameter value is not a uint8array.
+ * @param parameterValue The parameter value.
+ * @param parameterName The parameter name.
+ */
+function requireUint8Array(parameterValue, parameterName) {
+    if (!isUint8Array(parameterValue)) {
+        throw new TypeError("Parameter '".concat(parameterName, "' is not a Uint8Array"));
+    }
+}
+/**
+ * It throws a type error if the parameter value is not an object.
+ * @param parameterValue The parameter value.
+ * @param parameterName The parameter name.
+ */
+function requireObject(parameterValue, parameterName) {
+    if (!isObject(parameterValue)) {
+        throw new TypeError("Parameter '".concat(parameterName, "' is not an object"));
+    }
+}
+/**
+ * It throws a type error if the parameter value is not a bigint.
+ * @param parameterValue The parameter value.
+ * @param parameterName The parameter name.
+ */
+function requireBigInt(parameterValue, parameterName) {
+    if (!isBigInt(parameterValue)) {
+        throw new TypeError("Parameter '".concat(parameterName, "' is not a bigint"));
+    }
+}
+/**
+ * It throws a type error if the parameter value type is not part of the list of types.
+ * @param parameterValue The parameter value.
+ * @param parameterName The parameter name.
+ */
+function requireTypes(parameterValue, parameterName, types) {
+    for (var _i = 0, types_1 = types; _i < types_1.length; _i++) {
+        var type = types_1[_i];
+        if (!isSupportedType(type)) {
+            throw new Error("Type '".concat(type, "' is not supported"));
+        }
+    }
+    for (var _a = 0, types_2 = types; _a < types_2.length; _a++) {
+        var type = types_2[_a];
+        if (isType(parameterValue, type)) {
+            return;
+        }
+    }
+    throw new TypeError("Parameter '".concat(parameterName, "' is none of the following types: ").concat(types.join(", ")));
+}
+
+var errors = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    requireArray: requireArray,
+    requireBigInt: requireBigInt,
+    requireDefined: requireDefined,
+    requireFunction: requireFunction,
+    requireNumber: requireNumber,
+    requireObject: requireObject,
+    requireString: requireString,
+    requireTypes: requireTypes,
+    requireUint8Array: requireUint8Array
+});
+
+export { errors, types };