@bondsports/general

$3

The General package is a utility module that centralizes essential constants, enums, interfaces, and functions, providing a unified set of tools for use across multiple projects. By standardizing these utilities, the package ensures consistency, reduces redundancy, and simplifies development. It allows developers to focus on core business logic while relying on a robust foundation of reusable, maintainable, and efficient functions.

Installation

You can install the @bondsports/general package via npm:

``bash
npm install @bondsports/general
`

- Constants
- DEFAULT_CHUNK_SIZE
- DEFAULT_QUANTITY
- PRICE_DECIMAL_PLACES
- QUANTITY_DECIMAL_PLACES
- STRING_DEFAULT_LIMIT
- Enums
- PromiseStatusEnum
- HttpStatus
- PriceFieldEnum
- Array Functions
- recursiveFlattenArray
- recursiveFlattenObject
- insertIf
- uniqueIds
- uniqueItems
- uniqueObjectsList
- arraysEquals
- isArrayEmpty
- insertToMapArray
- arrayToMap
- isIntersecting
- String Functions
- titleCase
- generateRandomString
- fullName
- trimString
- isJSON
- isString
- Random Functions
- murmurHash3Generator
- randomNumber
- Price Functions
- samePrice
- biggerPrice
- biggerAmount
- validateAmount
- validatePrice
- validatePrices
- validateAmounts
- toFixed
- roundPriceCents
- roundQuantity
- sameQuantity
- calculatePriceFromTotal
- calculatePriceWithTax
- calculateTotalPriceWithTax
- calculateItemUnitPrice
- calculateUnitPriceFromTotal
- calculateQuantityFromTotal
- calculateUnitTax
- convertCentsToDollars
- getRoundingSplit
- splitPriceAmount
- calculateTotalPriceByPriceField
- calculateTotalPriceByPrices
- calculateTotalQuantity
- calculateDue
- calculateItemDue
- General Functions
- absoluteValue
- promiseAllSettled
- isInEnum
- extractValuesFromEnumArray
- useConditionalPromise
- validateFieldsToUpdate
- getClassAttributes
- parallelize

$3

---

Overview

The consts.ts file defines various constants that are used throughout the application to standardize operations such as processing arrays, handling quantities, formatting prices, and limiting string lengths. These constants help ensure consistency and reliability across different modules.

1. DEFAULT_CHUNK_SIZE
- Description: The default chunk size used for parallelizing array processing.
- Value: 10
- Usage Example:

`tsx
import { DEFAULT_CHUNK_SIZE } from '@bondsports/general';

const chunks = splitArrayIntoChunks(dataArray, DEFAULT_CHUNK_SIZE);
`

2. DEFAULT_QUANTITY
- Description: The default quantity value.
- Value: 1
- Usage Example:

`tsx
import { DEFAULT_QUANTITY } from '@bondsports/general';

function calculateTotal(quantity = DEFAULT_QUANTITY) {
return quantity * pricePerItem;
}
`

3. PRICE_DECIMAL_PLACES
- Description: The number of decimal places used for prices.
- Value: 2
- Usage Example:

`tsx
import { PRICE_DECIMAL_PLACES } from '@bondsports/general';

function formatPrice(price: number) {
return price.toFixed(PRICE_DECIMAL_PLACES);
}
`

4. QUANTITY_DECIMAL_PLACES
- Description: The number of decimal places used for quantity values.
- Value: 5
- Usage Example:

`tsx
import { QUANTITY_DECIMAL_PLACES } from '@bondsports/general';

function formatQuantity(quantity: number) {
return quantity.toFixed(QUANTITY_DECIMAL_PLACES);
}
`

5. STRING_DEFAULT_LIMIT
- Description: The default limit for strings.
- Value: 255
- Usage Example:

`tsx
import { STRING_DEFAULT_LIMIT } from '@bondsports/general';

function validateStringLength(str: string) {
return str.length <= STRING_DEFAULT_LIMIT;
}
`


$3

---

Overview

The enums.ts file defines several enumerations (enums) that are used throughout the application. These enums help to standardize values and provide clarity when dealing with common statuses, HTTP status codes, and pricing fields.

1. PromiseStatusEnum
- Description: Enum representing the status of a promise.
- Values:
- FULFILLED = 'fulfilled'
- REJECTED = 'rejected'
- Usage Example:

`tsx
import { PromiseStatusEnum } from '@bondsports/general';

function handlePromiseStatus(status: PromiseStatusEnum) {
if (status === PromiseStatusEnum.FULFILLED) {
console.log('The promise was fulfilled.');
} else if (status === PromiseStatusEnum.REJECTED) {
console.error('The promise was rejected.');
}
}
`

2. HttpStatus
- Description: Enum representing the HTTP status codes.
- Values:
- Includes common HTTP status codes such as:
- OK = 200
- CREATED = 201
- BAD_REQUEST = 400
- NOT_FOUND = 404
- INTERNAL_SERVER_ERROR = 500
- Usage Example:

`tsx
import { HttpStatus } from '@bondsports/general';

function handleHttpResponse(status: HttpStatus) {
switch (status) {
case HttpStatus.OK:
console.log('Request was successful.');
break;
case HttpStatus.NOT_FOUND:
console.error('Resource not found.');
break;
case HttpStatus.INTERNAL_SERVER_ERROR:
console.error('Internal server error.');
break;
default:
console.error('Unhandled status code:', status);
}
}
`

3. PriceFieldEnum
- Description: Enum representing the fields used for pricing.
- Values:
- PRICE = 'price'
- TOTAL_PRICE = 'totalPrice'
- AMOUNT = 'amount'
- PAID_AMOUNT = 'paidAmount'
- FEE_AMOUNT = 'feeAmount'
- REFUND_AMOUNT = 'refundAmount'
- DISCOUNT_AMOUNT = 'discountAmount'
- DISPLAY_FULL_PRICE = 'displayFullPrice'
- DISPLAY_TOTAL_PRICE_WITH_TAX = 'displayTotalPriceWithTax'
- Usage Example:

`tsx
import { PriceFieldEnum } from '@bondsports/general';

function calculateFieldTotal(items: any[], field: PriceFieldEnum) {
return items.reduce((sum, item) => sum + item[field], 0);
}

const items = [
{ price: 100, totalPrice: 110 },
{ price: 200, totalPrice: 220 }
];

const total = calculateFieldTotal(items, PriceFieldEnum.TOTAL_PRICE);
console.log('Total Price:', total); // Output: Total Price: 330
`


$3

---

Overview

The array.util.ts file provides a collection of utility functions designed to manipulate and manage arrays. These functions include operations for flattening nested structures, filtering unique items, and conditionally inserting elements into arrays.

1. recursiveFlattenArray
- Description: Recursively flattens an array of objects based on the specified properties.
- Parameters:
- array: The array to flatten.
- properties: The properties to flatten the array based on.
- Returns: The flattened array.
- Usage Example:

`tsx
import { recursiveFlattenArray } from '@bondsports/general';

const nestedArray = [{ id: 1, children: [{ id: 2, children: [] }] }];
const flatArray = recursiveFlattenArray(nestedArray, ['children']);
console.log(flatArray);
// Output: [{ id: 1, children: [{ id: 2, children: [] }] }, { id: 2, children: [] }]
`

2. recursiveFlattenObject
- Description: Recursively flattens an object by extracting specified properties.
- Parameters:
- entity: The object to be flattened.
- properties: The properties to be extracted from the object.
- Returns: An array of flattened objects.
- Usage Example:

`tsx
import { recursiveFlattenObject } from '@bondsports/general';

const nestedObject = { id: 1, children: { id: 2, children: {} } };
const flatObject = recursiveFlattenObject(nestedObject, ['children']);
console.log(flatObject);
// Output: [{ id: 1, children: { id: 2, children: {} } }, { id: 2, children: {} }]
`

3. insertIf
- Description: Inserts elements into an array if a condition is true.
- Parameters:
- condition: The condition to check.
- ...elements: The elements to insert into the array.
- Returns: The resulting array.
- Usage Example:

`tsx
import { insertIf } from '@bondsports/general';

const items = [
...insertIf(true, 1, 2, 3),
...insertIf(false, 1, 2, 3)
];
console.log(items); // Output: [1, 2, 3]
`

4. uniqueIds
- Description: Returns an array of unique IDs from the provided arrays of IDs.
- Parameters:
- idsArrays: Arrays of IDs to be merged and filtered.
- Returns: An array of unique IDs.
- Usage Example:

`tsx
import { uniqueIds } from '@bondsports/general';

const ids = uniqueIds([1, 2, 3], [3, 4, 5]);
console.log(ids); // Output: [1, 2, 3, 4, 5]
`

5. uniqueItems
- Description: Returns an array of unique items from multiple arrays.
- Parameters:
- arrays: The arrays to merge and extract unique items from.
- Returns: An array of unique items.
- Usage Example:

`tsx
import { uniqueItems } from '@bondsports/general';

const items = uniqueItems([1, 2, 3], [2, 3, 4], [4, 5, 6]);
console.log(items); // Output: [1, 2, 3, 4, 5, 6]
`

6. uniqueObjectsList
- Description: Returns an array of unique objects by given keys from multiple object arrays.
- Parameters:
- groupKeys: The unique keys we want to extract objects by.
- arrays: The arrays to merge and extract unique items from.
- Returns: An array of unique objects.
- Usage Example:

`tsx
import { uniqueObjectsList } from '@bondsports/general';

const objects = [
{ id: 1, name: 'John' },
{ id: 2, name: 'Jane' },
{ id: 1, name: 'John' }
];
const uniqueObjects = uniqueObjectsList(['id'], objects);
console.log(uniqueObjects); // Output: [{ id: 1, name: 'John' }, { id: 2, name: 'Jane' }]
`

7. arraysEquals
- Description: Checks if multiple arrays are equal to the first array.
- Parameters:
- firstArray: The first array to compare.
- ...arrays: Additional arrays to compare.
- Returns: Returns true if all arrays are equal, false otherwise.
- Usage Example:

`tsx
import { arraysEquals } from '@bondsports/general';

const isEqual = arraysEquals([1, 2, 3], [1, 2, 3], [1, 2, 3]);
console.log(isEqual); // Output: true
`

8. isArrayEmpty
- Description: Checks if an array is empty.
- Parameters:
- array: The array to check.
- Returns: True if the array is empty, false otherwise.
- Usage Example:

`tsx
import { isArrayEmpty } from '@bondsports/general';

const emptyCheck = isArrayEmpty([]);
console.log(emptyCheck); // Output: true
`

9. insertToMapArray
- Description: Inserts a value into an array within a map, using the specified key. If the key does not exist in the map, a new array is created and associated with the key.
- Parameters:
- map: The map to insert the value into.
- key: The key to associate the value with.
- value: The value to insert into the array.
- Returns: None.
- Usage Example:

`tsx
import { insertToMapArray } from '@bondsports/general';

const map = new Map();
insertToMapArray(map, 'key1', 'value1');
console.log(map.get('key1')); // Output: ['value1']
`

10. arrayToMap
- Description: Transforms an array of entities with an id field into a Map with id as a key and the entity as a value.
- Parameters:
- array: The array of entities to transform.
- Returns: The resulting Map with id as a key and the entity as a value.
- Usage Example:

`tsx
import { arrayToMap } from '@bondsports/general';

const entities = [{ id: 1, name: 'John' }, { id: 2, name: 'Jane' }];
const map = arrayToMap(entities);
console.log(map.get(1)); // Output: { id: 1, name: 'John' }
`

11. isIntersecting
- Description: Checks if two arrays have any common elements.
- Parameters:
- array: The first array to compare.
- other: The second array to compare.
- Returns: True if the arrays have common elements, false otherwise.
- Usage Example:

`tsx
import { isIntersecting } from '@bondsports/general';

const hasCommon = isIntersecting([1, 2, 3], [3, 4, 5]);
console.log(hasCommon); // Output: true
`


$3

---

Overview

The string.util.ts file provides a set of utility functions designed to manipulate and validate strings. These functions include operations for converting strings to title case, generating random strings, formatting names, trimming whitespace, and validating JSON data.

1. titleCase
- Description: Converts a string to title case.
- Parameters:
- text: The input string.
- Returns: The string converted to title case.
- Usage Example:

`tsx
import { titleCase } from '@bondsports/general';

const title = titleCase('hello world');
console.log(title); // Output: "Hello World"
`

2. generateRandomString
- Description: Generates a random string based on the provided seed, length, and character set.
- Parameters:
- seed: The seed value used for generating the random string.
- length: The length of the random string to be generated.
- charSet: The character set from which the random string will be composed.
- Returns: The randomly generated string.
- Usage Example:

`tsx
import { generateRandomString } from '@bondsports/general';

const randomString = generateRandomString('seed', 10, 'ABCDEFGHIJKLMNOPQRSTUVWXYZ');
console.log(randomString); // A random 10-character string
`

3. fullName
- Description: Generates a full name by combining first name and last name.
- Parameters:
- firstName: The first name (optional).
- lastName: The last name (optional).
- Returns: The full name as a string.
- Usage Example:

`tsx
import { fullName } from '@bondsports/general';

const name = fullName('John', 'Doe');
console.log(name); // Output: "John Doe"
`

4. trimString
- Description: Trims leading and trailing whitespace from a string.
- Parameters:
- text: The string to trim.
- Returns: The trimmed string, or null if the input string is empty or null.
- Usage Example:

`tsx
import { trimString } from '@bondsports/general';

const trimmed1 = trimString(' Hello World ');
console.log(trimmed1); // Output: "Hello World"

const trimmed2 = trimString(' ');
console.log(trimmed2); // Output: null
`

5. isJSON
- Description: Checks if the given data is a valid JSON string.
- Parameters:
- data: The data to be checked.
- Returns: A boolean indicating whether the data is a valid JSON string.
- Usage Example:

`tsx
import { isJSON } from '@bondsports/general';

const valid = isJSON('{"name": "John"}');
console.log(valid); // Output: true
`

6. isString
- Description: Checks if a value is a string.
- Parameters:
- value: The value to check.
- Returns: Returns true if the value is a string, false otherwise.
- Usage Example:

`tsx
import { isString } from '@bondsports/general';

const check = isString('Hello World');
console.log(check); // Output: true
`


$3

---

Overview

The random.util.ts file provides utility functions for generating pseudo-random numbers. These functions include generating random numbers with an optional seed value and creating a seeded pseudo-random number generator using the MurmurHash3 algorithm.

1. murmurHash3Generator
- Description: Generates a seeded pseudo-random number generator using the MurmurHash3 algorithm.
- Parameters:
- seed: The seed for the pseudo-random number generator.
- Returns: A function that generates pseudo-random numbers.
- Usage Example:

`tsx
import { murmurHash3Generator } from '@bondsports/general';

const randomGenerator = murmurHash3Generator('my-seed');
const randomNumber = randomGenerator();
console.log(randomNumber); // Output: A pseudo-random number based on the seed
`

2. randomNumber
- Description: Generates a random number between the specified range.
- Parameters:
- max: The maximum value of the range (inclusive).
- min: The minimum value of the range (default: 0).
- seed: An optional seed value to generate a deterministic random number.
- Returns: A function that, when called, generates a random number within the specified range.
- Usage Example:

`tsx
import { randomNumber } from '@bondsports/general';

const getRandomNumber = randomNumber(100, 0, 'my-seed');
console.log(getRandomNumber()); // Output: A deterministic random number between 0 and 100
`


$3

---

Overview

The price.util.ts file provides a collection of utility functions focused on handling and validating prices and quantities. These functions include operations for comparing prices, validating amounts, rounding values, and calculating totals.

1. samePrice
- Description: Checks if two prices are the same.
- Parameters:
- firstPrice: The first price to compare.
- secondPrice: The second price to compare.
- Returns: True if the prices are the same, false otherwise.
- Usage Example:

`tsx
import { samePrice } from '@bondsports/general';

const isSame = samePrice(10.00, 10.00);
console.log(isSame); // Output: true
`

2. biggerPrice
- Description: Checks if the first price is greater than the second price.
- Parameters:
- bigger: The bigger price.
- smaller: The smaller price.
- Returns: True if the first price is greater than the second price, false otherwise.
- Usage Example:

`tsx
import { biggerPrice } from '@bondsports/general';

const isBigger = biggerPrice(15.00, 10.00);
console.log(isBigger); // Output: true

`

3. biggerAmount
- Description: Checks if the first amount is greater than the second amount.
- Parameters:
- bigger: The bigger amount.
- smaller: The smaller amount.
- Returns: True if the first amount is greater than the second amount, false otherwise.
- Usage Example:

`tsx
import { biggerAmount } from '@bondsports/general';

const isBigger = biggerAmount(5.94, 3.17);
console.log(isBigger); // Output: true
`

4. validateAmount
- Description: Validates that an amount is valid (not null or undefined).
- Parameters:
- amount: The amount to validate.
- Returns: True if the amount is valid, false otherwise.
- Usage Example:

`tsx
import { validateAmount } from '@bondsports/general';

validateAmount(99.99); // Return: true
validateAmount(-10.00); // Return: true
validateAmount(0); // Return: true
validateAmount(null); // Return: false
`

5. validatePrice
- Description: Validates that a price is valid (greater than or equal to zero).
- Parameters:
- price: The price to validate.
- Returns: True if the price is valid, false otherwise.
- Usage Example:

`tsx
import { validatePrice } from '@bondsports/general';

validatePrice(20.00); // Return: true
validatePrice(0); // Return: true
validatePrice(-5.00); // Return: false
`

6. validatePrices
- Description: Validates an array of prices, checking if each price is valid (greater than or equal to zero).
- Parameters:
- prices: An array of prices to validate.
- Returns: True if all prices are valid, false otherwise.
- Usage Example:

`tsx
import { validatePrices } from '@bondsports/general';

const arePricesValid = validatePrices([10.00, 20.00, 30.00]);
console.log(arePricesValid); // Output: true
`

7. validateAmounts
- Description: Validates an array of amounts, checking if each price is valid (not null or undefined).
- Parameters:
- amounts: An array of amounts to validate.
- Returns: True if all amounts are valid, false otherwise.
- Usage Example:

`tsx
import { validateAmounts } from '@bondsports/general';

const areAmountsValid = validateAmounts([10.00, -20.00, 30.00]);
console.log(areAmountsValid); // Output: true
`

8. toFixed
- Description: Rounds a number to a specified precision and returns the result.
- Parameters:
- num: The number to round.
- precision: The number of decimal places to round to.
- Returns: The rounded number.
- Usage Example:

`tsx
import { toFixed } from '@bondsports/general';

const roundedNumber = toFixed(10.123456, 3);
console.log(roundedNumber); // Output: 10.123
`

9. roundPriceCents
- Description: Rounds the price to the nearest cent.
- Parameters:
- price: The price to round.
- Returns: The rounded price.
- Usage Example:

`tsx
import { roundPriceCents } from '@bondsports/general';

const roundedPrice = roundPriceCents(10.123);
console.log(roundedPrice); // Output: 10.12
`

10. roundQuantity
- Description: Rounds the given quantity to the specified decimal places.
- Parameters:
- amount: The amount to round.
- Returns: The rounded amount.
- Usage Example:

`tsx
import { roundQuantity } from '@bondsports/general';

const roundedQty = roundQuantity(5.67891);
console.log(roundedQty); // Output: 5.67891
`

11. sameQuantity
- Description: The function checks if two quantities are equal.
- Parameters:
- firstQuantity: The first quantity to compare.
- secondQuantity: The second quantity to compare.
- Returns: Returns true if the quantities are approximately equal (i.e., their difference is less than 0.0001), otherwise returns false.
- Usage Example:

`tsx
import { sameQuantity } from '@bondsports/general';

const quantity1 = 5.00001;
const quantity2 = 5.000012;

const areQuantitiesEqual = sameQuantity(quantity1, quantity2);
console.log(areQuantitiesEqual); // Output: true
`

12. calculatePriceFromTotal
- Description: Calculates the price from the total price, taking into account the quantity and optional tax percentage.
- Parameters:
- price: The price per unit.
- taxPercent: The tax percentage (optional).
- quantity: The quantity (default: DEFAULT_QUANTITY).
- Returns: The calculated price.
- Usage Example:

`tsx
import { calculatePriceFromTotal } from '@bondsports/general';

const price = calculatePriceFromTotal(110, 10);
console.log(price); // Output: 100.00
`

13. calculatePriceWithTax
- Description: Calculates the price with tax.
- Parameters:
- price: The price of the item.
- taxPercent: The tax percentage to apply (optional).
- quantity: The quantity of items (default: DEFAULT_QUANTITY).
- Returns: The calculated price with tax.
- Usage Example:

`tsx
import { calculatePriceWithTax } from '@bondsports/general';

const priceWithTax = calculatePriceWithTax(100, 10, 2);
console.log(priceWithTax); // Output: 220.00
`

14. calculateTotalPriceWithTax
- Description: Calculates the total price of an item including tax.
- Parameters:
- price: The price of the item.
- isTaxInclusive: Whether the price already includes tax.
- taxPercent: The tax percentage to apply, if isTaxInclusive is false.
- quantity: The quantity of items (default: DEFAULT_QUANTITY).
- Returns: The total price, including tax.
- Usage Example:

`tsx
import { calculateTotalPriceWithTax } from '@bondsports/general';

const totalPrice = calculateTotalPriceWithTax(100, false, 10);
console.log(totalPrice); // Output: 110.00
`

15. calculateItemUnitPrice
- Description: Calculates the item unit price based on the given unit price, tax-inclusive status, and tax percentage.
- Parameters:
- unitPrice: The unit price before tax.
- isTaxInclusive: A flag indicating whether the price includes tax.
- taxPercent: The tax percentage.
- Returns: The calculated unit price.
- Usage Example:

`tsx
import { calculateItemUnitPrice } from '@bondsports/general';

const unitPrice = calculateItemUnitPrice(100, true, 10);
console.log(unitPrice); // Output: 90.91
`

16. calculateUnitPriceFromTotal
- Description: Calculates the unit price based on the given total price, tax-inclusive status, tax percentage, and quantity.
- Parameters:
- totalPrice: The total price.
- isTaxInclusive: A flag indicating whether the price includes tax.
- taxPercent: The tax percentage.
- quantity: The quantity of items (default: DEFAULT_QUANTITY).
- Returns: The calculated unit price.
- Usage Example:

`tsx
import { calculateUnitPriceFromTotal } from '@bondsports/general';

const unitPrice = calculateUnitPriceFromTotal(330, true, 10, 3);
console.log(unitPrice); // Output: 110.00
`

17. calculateQuantityFromTotal
- Description: Calculates the quantity based on the total amount, unit price, and tax percentage.
- Parameters:
- totalAmount: The total amount.
- unitPrice: The unit price of the item.
- isTaxInclusive: Indicates whether the tax is included in the unit price.
- taxPercentage: The tax percentage (optional).
- Returns: The calculated quantity.
- Usage Example:

`tsx
import { calculateQuantityFromTotal } from '@bondsports/general';

const quantity = calculateQuantityFromTotal(110, 100, true, 10);
console.log(quantity); // Output: 1.00
`

18. calculateUnitTax
- Description: Calculates the unit tax based on the unit price, tax inclusiveness, and tax percentage.
- Parameters:
- unitPrice: The unit price.
- isTaxInclusive: Indicates whether the tax is included in the unit price.
- taxPercent: The tax percentage.
- Returns: The calculated unit tax.
- Usage Example:

`tsx
import { calculateUnitTax } from '@bondsports/general';

const unitTax = calculateUnitTax(100, true, 10);
console.log(unitTax); // Output: 9.09
`

19. convertCentsToDollars
- Description: Converts the given price in cents to dollars.
- Parameters:
- price: The price in cents.
- Returns: The price in dollars.
- Usage Example:

`tsx
import { convertCentsToDollars } from '@bondsports/general';

const dollars = convertCentsToDollars(10000);
console.log(dollars); // Output: 100.00
`

20. getRoundingSplit
- Description: Calculates the rounding split between a requested price and an actual price.
- Parameters:
- requestedPrice: The requested price.
- price: The actual price.
- Returns: An object containing the number of splits and the split amount.
- Usage Example:

`tsx
import { getRoundingSplit } from '@bondsports/general';

const roundingSplit = getRoundingSplit(100.05, 100);
console.log(roundingSplit); // Output: { splitsNumber: 5, splitAmount: 0.01 }
`

21. splitPriceAmount
- Description: Splits the given amount into multiple parts.
- Parameters:
- amount: The amount to be split.
- splitsNumber: The number of splits to be made (default: 1).
- Returns: An array of numbers representing the split amounts.
- Usage Example:

`tsx
import { splitPriceAmount } from '@bondsports/general';

const splits = splitPriceAmount(100, 3);
console.log(splits); // Output: [33.33, 33.33, 33.34]
`

22. calculateTotalPriceByPriceField
- Description: Calculates the total price by a specified price field in an array of items.
- Parameters:
- items: The array of items.
- startPrice: The starting price (default: 0).
- priceField: The price field to use for calculation (default: PriceFieldEnum.PRICE).
- Returns: The total price.
- Usage Example:

`tsx
import { calculateTotalPriceByPriceField } from '@bondsports/general';

const items = [{ price: 100 }, { price: 200 }, { price: 300 }];
const totalPrice = calculateTotalPriceByPriceField(items);
console.log(totalPrice); // Output: 600.00
`

23. calculateTotalPriceByPrices
- Description: Calculates the total price by summing up the prices in the given array.
- Parameters:
- prices: An array of prices.
- startPrice: The starting price for the calculation (default: 0).
- Returns: The total price.
- Usage Example:

`tsx
import { calculateTotalPriceByPrices } from '@bondsports/general';

const prices = [100, 200, 300];
const totalPrice = calculateTotalPriceByPrices(prices);
console.log(totalPrice); // Output: 600.00
`

24. calculateTotalQuantity
- Description: Calculates the total quantity by summing up the given quantities.
- Parameters:
- quantities: An array of quantities to be summed up.
- startQuantity: The starting quantity for the calculation (default: 0).
- Returns: The total quantity.
- Usage Example:

`tsx
import { calculateTotalQuantity } from '@bondsports/general';

const quantities = [1, 2, 3];
const totalQty = calculateTotalQuantity(quantities);
console.log(totalQty); // Output: 6
`

25. calculateDue
- Description: Calculates the amount due based on the price and the amount already paid.
- Parameters:
- price: The total price of the item.
- paidAmount: The amount already paid (default: 0).
- Returns: The amount due.
- Usage Example:

`tsx
import { calculateDue } from '@bondsports/general';

const amountDue = calculateDue(100, 50);
console.log(amountDue); // Output: 50.00
`

26. calculateItemDue
- Description: Calculates the amount due for an item based on its price and the amount already paid.
- Parameters:
- item: The item, which must have a price and paidAmount property.
- Returns: The amount due for the item.
- Usage Example:

`tsx
import { calculateItemDue } from '@bondsports/general';

const item = { price: 100, paidAmount: 50 };
const amountDue = calculateItemDue(item);
console.log(amountDue); // Output: 50.00
`


$3

---

Overview

The general.util.ts file provides a versatile set of utility functions designed for general-purpose use across various parts of an application. These functions include operations for handling promises, working with enums, validating values, and performing calculations.

1. absoluteValue
- Description: Calculates the absolute value of a number.
- Parameters:
- value: The number to calculate the absolute value of.
- Returns: The absolute value of the input number.
- Usage Example:

`tsx
import { absoluteValue } from '@bondsports/general';

const absValue = absoluteValue(-42);
console.log(absValue); // Output: 42
`

2. promiseAllSettled
- Description: Executes multiple promises and returns an array of settled results.
- Parameters:
- promises: The promises to execute.
- Returns: A promise that resolves to an array of fulfilled values.
- Usage Example:

`tsx
import { promiseAllSettled } from '@bondsports/general';

const promises = [
Promise.resolve(1),
Promise.resolve(2),
Promise.reject(new Error('Failed'))
];

promiseAllSettled(...promises)
.then(results => console.log(results))
.catch(error => console.error(error));
`

3. isInEnum
- Description: Checks if a value is a valid member of an enum.
- Parameters:
- enumType: The enum to check against.
- value: The value to check.
- Returns: True if the value is a valid member of the enum, false otherwise.
- Usage Example:

`tsx
import { isInEnum, HttpStatus } from '@bondsports/general';

const isValid = isInEnum(HttpStatus, 200);
console.log(isValid); // Output: true
`

4. extractValuesFromEnumArray
- Description: Extracts values from an array of enums.
- Parameters:
- values: The array of values to extract from.
- enumType: The enum type to filter the values against.
- Returns: An array of values that are present in the enum.
- Usage Example:

`tsx
import {
extractValuesFromEnumArray,
HttpStatus
} from '@bondsports/general';

const validStatuses = extractValuesFromEnumArray([200, 404, 999], HttpStatus);
console.log(validStatuses); // Output: [200, 404]
`

5. useConditionalPromise
- Description: Executes a promise-based operation conditionally based on a boolean condition.
- Parameters:
- operation: The promise-based operation to be executed.
- condition: The boolean condition that determines whether to execute the operation or use the fallback.
- fallback: An optional fallback function to be executed if the condition is false.
- Returns: A promise that resolves to the result of the operation or the fallback function.
- Usage Example:

`tsx
import { useConditionalPromise } from '@bondsports/general';

const operation = () => Promise.resolve('Success');
const fallback = () => 'Fallback';

useConditionalPromise(operation, true, fallback)
.then(result => console.log(result)); // Output: 'Success'
`

6. validateFieldsToUpdate
- Description: Validates the fields to update in an entity object.
- Parameters:
- classType: The constructor function of the entity object.
- entity: The original entity object.
- fieldsToUpdate: The fields to update in the entity object.
- Returns: True if there are fields to update, false otherwise.
- Usage Example:

`tsx
import { validateFieldsToUpdate } from '@bondsports/general';

class User {
id: number;
name: string;
email: string;
}

const user = new User();
user.id = 1;
user.name = 'John';
user.email = 'john@example.com';

const fieldsToUpdate = { name: 'John Doe' };

const isValid = validateFieldsToUpdate(User, user, fieldsToUpdate);
console.log(isValid); // Output: true
`

7. getClassAttributes
- Description: Retrieves the attributes of a class instance.
- Parameters:
- classType: The constructor function of the class.
- Returns: An array of attribute names.
- Usage Example:

`tsx
import { getClassAttributes } from './general.util';

class Product {
id: number;
name: string;
price: number;
}

const attributes = getClassAttributes(Product);
console.log(attributes); // Output: ['id', 'name', 'price']
`

8. parallelize
- Description: Executes the given async function in parallel for each item in the array. Returns a promise that resolves to an array of results.
- Parameters:
- array: The array of items to process.
- func: The async function to execute for each item.
- chunkSize: The number of items to process in each chunk (default: DEFAULT_CHUNK_SIZE).
- Returns: A promise that resolves to an array of results.
- Usage Example:

`tsx
import { parallelize } from './general.util';

async function processItems(items: any[]) {
const results = await parallelize(items, async (item) => {
// some async processing
return item;
});
console.log(results);
}
``

---