@revolugo/common 6.10.7-beta.1 → 6.10.7-beta.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@revolugo/common",
-  "version": "6.10.7-beta.1",
+  "version": "6.10.7-beta.10",
   "private": false,
   "description": "Revolugo common",
   "author": "Revolugo",
@@ -26,7 +26,6 @@
     "change-case": "5.4.4",
     "dayjs": "1.11.18",
     "ky": "1.11.0",
-    "lodash-es": "4.17.21",
     "slugify": "1.6.6",
     "uuid": "13.0.0"
   },

package/src/cancellation-policies.ts

@@ -1,4 +1,4 @@
-import { compact } from './utils/array-tools.ts'
+import { compact } from './utils/compact.ts'
 import { type Dayjs, dayjs } from './utils/dayjs.ts'
 import { isEmpty } from './utils/is-empty.ts'
 

package/src/currencies/index.ts

@@ -1,6 +1,6 @@
 /* eslint-disable max-lines */
 import { Currency } from '../constants/currencies.ts'
-import { pick } from '../utils/object-tools.ts'
+import { pick } from '../utils/pick.ts'
 
 import type { ICurrency } from '../types/currency.ts'
 

package/src/utils/{math.ts → amount-from-percentage.ts}

@@ -1,13 +1,3 @@
-export function weightedMean(values: number[], weights: number[]): number {
-  const sum = values.reduce(
-    (acc: number, val: number, i: number) => acc + val * (weights[i] ?? 0),
-    0,
-  )
-  const sumWeights = weights.reduce((acc: number, val: number) => acc + val, 0)
-
-  return sum / sumWeights
-}
-
 export function amountFromPercentage(
   percentage: number,
   amount: number,

package/src/utils/case-transformers.ts

@@ -23,7 +23,6 @@ export enum CaseTransformer {
   Snake = 'snakeCase',
 }
 
-/* @__PURE__ */
 const CASE_TRANSORMERS_MAPPING = {
   [CaseTransformer.Camel]: camelCase,
   [CaseTransformer.Capital]: capitalCase,

package/src/utils/chunk.ts

@@ -0,0 +1,7 @@
+export function chunk<T>(array: T[], size: number): T[][] {
+  const chunks: T[][] = []
+  for (let i = 0; i < array.length; i += size) {
+    chunks.push(array.slice(i, i + size))
+  }
+  return chunks
+}

package/src/utils/colors.ts

@@ -1,4 +1,4 @@
-import { generateNumbersFromStr } from './numbers.ts'
+import { generateNumbersFromStr } from './generate-numbers-from-str.ts'
 
 export function generateRandomColorFromString(
   str: string,

package/src/utils/compact-object.ts

@@ -0,0 +1,7 @@
+import { isNil } from './is-nil.ts'
+
+export function compactObject<T extends object>(obj: T): Partial<T> {
+  return Object.fromEntries(
+    Object.entries(obj).filter(([, value]) => !isNil(value)),
+  ) as Partial<T>
+}

package/src/utils/compact.ts

@@ -0,0 +1,28 @@
+export function compact<T>(
+  array: (T | null | undefined)[] | null | undefined,
+): Exclude<T, null | undefined>[] {
+  const length = array === null || array === undefined ? 0 : array.length
+  let index = -1
+  let resIndex = 0
+  const result: Exclude<T, null | undefined>[] = []
+
+  while (index < length) {
+    index += 1
+    if (array !== null && array !== undefined) {
+      const value = array[index]
+
+      if (
+        value !== null &&
+        value !== undefined &&
+        value !== false &&
+        value !== 0 &&
+        value !== ''
+      ) {
+        result[resIndex] = value as Exclude<T, null | undefined>
+        resIndex += 1
+      }
+    }
+  }
+
+  return result
+}

package/src/utils/compute-margin-rate.ts

@@ -0,0 +1,13 @@
+export function computeMarginRate(
+  buyingPrice: number | string,
+  sellingPrice: number | string,
+): number {
+  const buyingPriceNum = Number(buyingPrice)
+  const sellingPriceNum = Number(sellingPrice)
+
+  if (Number.isNaN(sellingPriceNum) || Number.isNaN(buyingPriceNum)) {
+    throw new TypeError('sellingPrice or buyingPrice is NaN')
+  }
+
+  return Number((1 - buyingPriceNum / sellingPriceNum).toPrecision(10))
+}

package/src/utils/compute-selling-price.ts

@@ -0,0 +1,12 @@
+export function computeSellingPrice(
+  buyingPrice: number | string | null = 0,
+  rate: number | string | null = 0,
+): number {
+  if (Number.isNaN(Number(buyingPrice)) || Number.isNaN(Number(rate))) {
+    throw new TypeError('price or rate is NaN')
+  }
+
+  const sellingPrice = Number(buyingPrice) / (1 - Number(rate))
+
+  return Math.ceil(Math.floor(sellingPrice * 100) / 100)
+}

package/src/utils/defaults-deep.ts

@@ -0,0 +1,85 @@
+/**
+ * Drop-in native TypeScript replacement for `lodash-es` `defaultsDeep`.
+ *
+ * Behaviour matched (carefully):
+ * - Mutates and returns the first argument (target).
+ * - Assigns own and *inherited* enumerable **string-keyed** properties from sources
+ *   to the target only when the target's property is `undefined`.
+ * - Recursively assigns (deep) when both target and source values are objects/arrays.
+ * - Does not copy symbol-keyed properties (matches the "string keyed" behaviour).
+ * - Preserves `null` (i.e. `null` is NOT considered `undefined` so it won't be overwritten).
+ * - Avoids infinite recursion for circular source structures.
+ */
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+type AnyObject = Record<string, any>
+
+function isObject(value: any): value is AnyObject {
+  return value !== null && typeof value === 'object'
+}
+
+export function defaultsDeep<T>(
+  object: T,
+  ...sources: any[]
+): T extends AnyObject ? T : any {
+  // Ensure we always return an object reference we can mutate (lodash creates/uses {} when target is falsy)
+  const target: AnyObject = (
+    object === null || object === undefined ? {} : object
+  ) as AnyObject
+
+  // WeakMap to track already-cloned source objects so circular refs won't blow the stack
+  const seen = new WeakMap<object, object>()
+
+  function applyDefaults(dst: AnyObject, src: any) {
+    // Only iterate string-keyed enumerable properties (own + inherited) => for...in
+    for (const key in src) {
+      if (Object.hasOwn(src, key)) {
+        const srcVal = src[key]
+        const dstVal = dst[key]
+
+        // only apply when destination is strictly `undefined` (lodash semantics)
+        if (dstVal === undefined) {
+          // eslint-disable-next-line max-depth
+          if (isObject(srcVal)) {
+            // If we've already cloned this source object (circular), reuse it
+            // eslint-disable-next-line max-depth
+            if (seen.has(srcVal)) {
+              dst[key] = seen.get(srcVal)
+            } else {
+              // Prepare new container (array vs object)
+              const created = Array.isArray(srcVal)
+                ? ([] as unknown[])
+                : ({} as AnyObject)
+              // remember mapping to handle circular refs
+              seen.set(srcVal, created)
+
+              // Recursively fill created from srcVal
+              applyDefaults(created, srcVal)
+
+              // assign the created clone as the default
+              dst[key] = created
+            }
+          } else {
+            // Primitive or function: assign directly
+            dst[key] = srcVal
+          }
+        } else if (isObject(dstVal) && isObject(srcVal)) {
+          // destination already has a value (not undefined) and both are objects => recurse
+          // (do not overwrite existing non-undefined values)
+          // Note: do not treat arrays specially here; Array.isArray check only used when creating new value
+          applyDefaults(dstVal, srcVal)
+        }
+        // else: destination has a non-undefined primitive or non-object - skip (do not overwrite)
+      }
+    }
+  }
+
+  for (const src of sources) {
+    if (src !== null && src !== undefined) {
+      // If source itself has been seen (unlikely across top-level sources), we still traverse it
+      applyDefaults(target, src)
+    }
+  }
+
+  return target as any
+}

package/src/utils/delay.ts

@@ -0,0 +1,5 @@
+export function delay(duration: number): Promise<void> {
+  return new Promise(resolve => {
+    setTimeout(resolve, duration)
+  })
+}

package/src/utils/generate-numbers-from-str.ts

@@ -0,0 +1,15 @@
+export function generateNumbersFromStr(str: string): [number, number] {
+  let hash = 5381
+  for (let i = 0; i < str.length; i++) {
+    // eslint-disable-next-line no-bitwise
+    hash = (hash << 5) + hash + str.charCodeAt(i)
+  }
+
+  // Generate two numbers using the hash
+  // eslint-disable-next-line no-bitwise
+  const num1 = (hash & 0xff_ff) / 0xff_ff
+  // eslint-disable-next-line no-bitwise
+  const num2 = ((hash >> 16) & 0xff_ff) / 0xff_ff
+
+  return [num1, num2]
+}

package/src/utils/generate-pseudo-random-string.ts

@@ -0,0 +1,3 @@
+export function generatePseudoRandomString(length: number): string {
+  return Array.from({ length }, () => Math.random().toString(36)[2]).join('')
+}

package/src/utils/get-guest-count.ts

@@ -1,6 +1,5 @@
-import { parseChildren } from './children-tools.ts'
+import { parseChildren } from './parse-children.ts'
 
-/* @__PURE__ */
 export const CHILDREN_FREE_BREAKFAST_AGE_LIMIT = 4
 
 export function getGuestCount(

package/src/utils/get-random-element-from-array.ts

@@ -0,0 +1,10 @@
+export function getRandomElementFromArray<T>(array: readonly T[]): T {
+  if (array.length === 0) {
+    throw new Error('Cannot get random element from empty array')
+  }
+  const element = array[Math.floor(Math.random() * array.length)]
+  if (element === undefined) {
+    throw new Error('Array element is undefined')
+  }
+  return element
+}

package/src/utils/get-random-hex-color.ts

@@ -0,0 +1,5 @@
+export function getRandomHexColor(): string {
+  const hex = Math.floor(Math.random() * 0xffffff).toString(16)
+
+  return hex.padStart(6, '0').toUpperCase()
+}

package/src/utils/{random.ts → get-random-int.ts}

@@ -4,9 +4,3 @@ export function getRandomInt(min: number, max: number): number {
 
   return Math.floor(Math.random() * (roundedMax - roundedMin + 1)) + roundedMin
 }
-
-export function getRandomHexColor(): string {
-  const hex = Math.floor(Math.random() * 0xffffff).toString(16)
-
-  return hex.padStart(6, '0').toUpperCase()
-}

package/src/utils/index.ts

@@ -1,31 +1,50 @@
 export * from './add-classes.ts'
-export * from './array-tools.ts'
+export * from './amount-from-percentage.ts'
 export * from './case-transformers.ts'
+export * from './chunk.ts'
 export * from './colors.ts'
+export * from './compact-object.ts'
+export * from './compact.ts'
+export * from './compute-margin-rate.ts'
+export * from './compute-selling-price.ts'
+export * from './create-composite-key.ts'
 export * from './currency.ts'
 export * from './dates.ts'
 export * from './dayjs.ts'
 export * from './debounce.ts'
+export * from './defaults-deep.ts'
+export * from './delay.ts'
 export * from './find-unique-keys.ts'
+export * from './generate-numbers-from-str.ts'
+export * from './generate-pseudo-random-string.ts'
 export * from './get-guest-count.ts'
+export * from './get-random-element-from-array.ts'
+export * from './get-random-hex-color.ts'
+export * from './get-random-int.ts'
 export * from './group-by.ts'
+export * from './images.ts'
 export * from './is-empty.ts'
 export * from './is-equal.ts'
+export * from './is-nil.ts'
+export * from './key-by.ts'
 export * from './lang-default-fallbacks.ts'
-export * from './math.ts'
-export * from './numbers.ts'
-export * from './object-tools.ts'
+export * from './merge.ts'
+export * from './omit-by.ts'
+export * from './omit.ts'
+export * from './parse-children.ts'
+export * from './pick.ts'
 export * from './poller.ts'
-export * from './promise-tools.ts'
-export * from './random.ts'
+export * from './prepare-ts-query.ts'
+export * from './promise-timeout.ts'
+export * from './random-int.ts'
 export * from './range.ts'
-export * from './strings.ts'
+export * from './shake.ts'
+export * from './shuffle-array.ts'
+export * from './sort-by.ts'
+export * from './sum-by.ts'
 export * from './sum.ts'
 export * from './to-boolean.ts'
 export * from './uniq-by.ts'
+export * from './uniq-with.ts'
 export * from './validators.ts'
-export * from './value-tools.ts'
-export * from './create-composite-key.ts'
-export * from './children-tools.ts'
-export * from './shake.ts'
-export * from './images.ts'
+export * from './weighted-mean.ts'

package/src/utils/key-by.ts

@@ -0,0 +1,25 @@
+/**
+ * Creates an object composed of keys generated from the results of running each element of collection through iteratee.
+ * The corresponding value of each key is the last element responsible for generating the key.
+ *
+ * @param collection - The collection to iterate over
+ * @param iteratee - The iteratee to transform keys. Can be a function or a property name
+ * @returns Returns the composed aggregate object
+ */
+export function keyBy<T>(
+  collection: T[] | null | undefined,
+  iteratee: ((value: T) => string | number) | keyof T,
+): Record<string, T> {
+  return (
+    collection?.reduce<Record<string, T>>((acc, item) => {
+      if (item === undefined || item === null) {
+        return acc
+      }
+
+      const key =
+        typeof iteratee === 'function' ? iteratee(item) : String(item[iteratee])
+      acc[key] = item
+      return acc
+    }, {}) || {}
+  )
+}

package/src/utils/merge.ts

@@ -0,0 +1,140 @@
+/**
+ * Checks if a value is a plain object (created via {} or new Object).
+ * Lodash treats only plain objects as recursively mergable.
+ */
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+  if (value === null || typeof value !== 'object') {
+    return false
+  }
+  const proto = Object.getPrototypeOf(value)
+  return proto === Object.prototype || proto === null
+}
+
+/**
+ * Deep clones an object, handling arrays and plain objects
+ */
+function cloneDeep<T>(value: T, seen = new WeakSet()): T {
+  if (value === null || value === undefined || typeof value !== 'object') {
+    return value
+  }
+
+  // Handle circular references
+  if (seen.has(value as object)) {
+    return value
+  }
+  seen.add(value as object)
+
+  if (Array.isArray(value)) {
+    return value.map(item => cloneDeep(item, seen)) as T
+  }
+
+  if (isPlainObject(value)) {
+    const cloned: Record<string, unknown> = {}
+    for (const key in value) {
+      if (Object.hasOwn(value, key)) {
+        cloned[key] = cloneDeep(value[key], seen)
+      }
+    }
+    return cloned as T
+  }
+
+  // For other object types (Date, RegExp, etc.), return as-is
+  return value
+}
+
+/**
+ * Recursively merges source into target, following lodash.merge semantics.
+ */
+function mergeObject(
+  target: Record<string, unknown>,
+  source: Record<string, unknown>,
+  seen = new WeakSet<object>(),
+): void {
+  if (!isPlainObject(source) || !isPlainObject(target)) {
+    return
+  }
+
+  // Circular reference guard
+  if (source === target || seen.has(source)) {
+    return
+  }
+  seen.add(source)
+
+  // Lodash merges own + inherited enumerable string-keyed props
+  for (const key in source) {
+    if (Object.hasOwn(source, key)) {
+      const srcVal = source[key]
+      const tgtVal = target[key]
+
+      if (isPlainObject(srcVal) && isPlainObject(tgtVal)) {
+        mergeObject(tgtVal as Record<string, unknown>, srcVal, seen)
+      } else if (Array.isArray(srcVal) && Array.isArray(tgtVal)) {
+        // eslint-disable-next-line @typescript-eslint/no-use-before-define
+        target[key] = mergeArrays(tgtVal, srcVal, seen)
+      } else {
+        // Override with source value - this is the key fix
+        target[key] = cloneDeep(srcVal, seen)
+      }
+    }
+  }
+}
+
+/**
+ * Merges two arrays by index, lodash style.
+ * - Recursively merges plain objects/arrays
+ * - Overwrites with source otherwise
+ */
+function mergeArrays(
+  target: unknown[],
+  source: unknown[],
+  seen: WeakSet<object>,
+): unknown[] {
+  const result = target.slice()
+
+  for (let i = 0; i < source.length; i++) {
+    const srcVal = source[i]
+    const tgtVal = result[i]
+
+    if (isPlainObject(srcVal) && isPlainObject(tgtVal)) {
+      const merged: Record<string, unknown> = { ...tgtVal }
+      mergeObject(merged, srcVal, seen)
+      result[i] = merged
+    } else if (Array.isArray(srcVal) && Array.isArray(tgtVal)) {
+      result[i] = mergeArrays(tgtVal, srcVal, seen)
+    } else {
+      result[i] = cloneDeep(srcVal, seen)
+    }
+  }
+
+  return result
+}
+
+/**
+ * A drop-in replacement for lodash-es merge.
+ *
+ * - Recursively merges own and inherited enumerable string-keyed properties.
+ * - Arrays and plain objects are merged by index/key.
+ * - Non-plain objects (Date, RegExp, Map, Set, custom classes, etc.)
+ *   are assigned by reference (not cloned).
+ * - `undefined` does not overwrite an existing value.
+ * - Symbols and non-enumerables are ignored.
+ * - Prototype pollution is *not* prevented (matches lodash behavior).
+ */
+export function merge<T extends Record<string, unknown>>(
+  object: T,
+  ...sources: unknown[]
+): T {
+  if (!isPlainObject(object)) {
+    throw new TypeError('Target must be a plain object')
+  }
+
+  const seen = new WeakSet<object>()
+
+  for (const src of sources) {
+    if (src !== null && src !== undefined) {
+      mergeObject(object, src as Record<string, unknown>, seen)
+    }
+  }
+
+  return object
+}

package/src/utils/omit-by.ts

@@ -0,0 +1,37 @@
+/**
+ * Creates an object composed of the own enumerable properties of object that predicate doesn't return truthy for.
+ * The predicate is invoked with two arguments: (value, key).
+ * If predicate is a string, it omits the property with that key name.
+ *
+ * @param object - The source object
+ * @param predicate - The function invoked per property or a string key to omit
+ * @returns Returns the new object
+ */
+export function omitBy<T extends object>(
+  object: T,
+  predicate: ((value: T[keyof T], key: keyof T) => boolean) | string,
+): Partial<T> {
+  const result = {} as Partial<T>
+
+  for (const key in object) {
+    if (Object.hasOwn(object, key)) {
+      const value = object[key]
+
+      // If predicate is a string, check if key matches
+      if (typeof predicate === 'string') {
+        // eslint-disable-next-line max-depth
+        if (key !== predicate) {
+          result[key] = value
+        }
+      } else if (typeof predicate === 'function') {
+        // If predicate is a function, use it
+        // eslint-disable-next-line max-depth
+        if (!predicate(value, key)) {
+          result[key] = value
+        }
+      }
+    }
+  }
+
+  return result
+}

package/src/utils/omit.ts

@@ -0,0 +1,39 @@
+/**
+ * Creates a shallow clone of `object` excluding the given own enumerable keys.
+ * Accepts a single key or an array of keys. Symbol keys are supported.
+ * If `object` is nullish, returns an empty object.
+ */
+export function omit<T extends object, K extends keyof T>(
+  object: T | null | undefined,
+  keys: readonly K[] | K,
+): Omit<T, K> {
+  if (object === null || object === undefined) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return {} as any
+  }
+
+  const keysArray = (
+    Array.isArray(keys) ? keys : [keys]
+  ) as readonly (keyof T)[]
+  const keysSet = new Set<keyof T>(keysArray as (keyof T)[])
+
+  const result: Partial<T> = {}
+
+  // Copy string/number keys
+  for (const key in object) {
+    if (Object.hasOwn(object, key) && !keysSet.has(key as keyof T)) {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      ;(result as any)[key] = object[key as keyof T]
+    }
+  }
+
+  // Copy symbol keys
+  for (const sym of Object.getOwnPropertySymbols(object)) {
+    if (!keysSet.has(sym as keyof T)) {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      ;(result as any)[sym as unknown as keyof T] = (object as any)[sym]
+    }
+  }
+
+  return result as Omit<T, K>
+}

package/src/utils/pick.ts

@@ -0,0 +1,12 @@
+export function pick<T extends object, K extends keyof T>(
+  obj: T,
+  keys: readonly K[],
+): Pick<T, K> {
+  const result = {} as Pick<T, K>
+  for (const key of keys) {
+    if (Object.hasOwn(obj, key)) {
+      result[key] = obj[key]
+    }
+  }
+  return result
+}

package/src/utils/poller.ts

@@ -21,7 +21,6 @@ export type TPollerEvents<V extends IPollerResponse = IPollerResponse> = {
   [k in TPollerEventName]: TPollerEventCallback<V>
 }
 
-/* @__PURE__ */
 const INTERVAL = 1500
 
 export interface IPollerOptions<U> {

package/src/utils/{strings.ts → prepare-ts-query.ts}

@@ -1,8 +1,3 @@
-export function generatePseudoRandomString(length: number): string {
-  return Array.from({ length }, () => Math.random().toString(36)[2]).join('')
-}
-
-/* @__PURE__ */
 const TS_QUERY_SPECIAL_CHARS = new Set([
   '&',
   '|',
@@ -15,7 +10,6 @@ const TS_QUERY_SPECIAL_CHARS = new Set([
   '@',
 ])
 
-/* @__PURE__ */
 const REGEX_SPECIAL_CHARS = new Set(['|', '(', ')'])
 
 export function prepareTsQuery(query: string): string | null {

package/src/utils/{promise-tools.ts → promise-timeout.ts}

@@ -1,9 +1,3 @@
-export function delay(duration: number): Promise<void> {
-  return new Promise(resolve => {
-    setTimeout(resolve, duration)
-  })
-}
-
 export function promiseTimeout<T>(
   delayAmount: number,
   valueToReturn: T,

package/src/utils/random-int.ts

@@ -0,0 +1,3 @@
+export function randomInt(min: number, max: number): number {
+  return Math.floor(Math.random() * (max - min + 1) + min)
+}

package/src/utils/shuffle-array.ts

@@ -0,0 +1,13 @@
+export function shuffleArray<T>(array: T[]): T[] {
+  const shuffled = [...array]
+  for (let i = shuffled.length - 1; i > 0; i--) {
+    const j = Math.floor(Math.random() * (i + 1))
+    const temp = shuffled[i]
+    const swap = shuffled[j]
+    if (temp !== undefined && swap !== undefined) {
+      shuffled[i] = swap
+      shuffled[j] = temp
+    }
+  }
+  return shuffled
+}

package/src/utils/{array-tools.ts → sort-by.ts}

@@ -1,106 +1,3 @@
-export function chunk<T>(array: T[], size: number): T[][] {
-  const chunks: T[][] = []
-  for (let i = 0; i < array.length; i += size) {
-    chunks.push(array.slice(i, i + size))
-  }
-  return chunks
-}
-
-export function getRandomElementFromArray<T>(array: readonly T[]): T {
-  if (array.length === 0) {
-    throw new Error('Cannot get random element from empty array')
-  }
-  const element = array[Math.floor(Math.random() * array.length)]
-  if (element === undefined) {
-    throw new Error('Array element is undefined')
-  }
-  return element
-}
-
-export function shuffleArray<T>(array: T[]): T[] {
-  const shuffled = [...array]
-  for (let i = shuffled.length - 1; i > 0; i--) {
-    const j = Math.floor(Math.random() * (i + 1))
-    const temp = shuffled[i]
-    const swap = shuffled[j]
-    if (temp !== undefined && swap !== undefined) {
-      shuffled[i] = swap
-      shuffled[j] = temp
-    }
-  }
-  return shuffled
-}
-
-type Comparator<T> = (a: T, b: T) => boolean
-
-export function uniqWith<T>(array: T[], comparator: Comparator<T>): T[] {
-  if (!Array.isArray(array) || typeof comparator !== 'function') {
-    throw new TypeError(
-      'First argument must be an array and second argument must be a function',
-    )
-  }
-
-  return array.reduce((unique: T[], current: T) => {
-    // Check if current item matches any existing item in unique array based on comparator
-    const hasDuplicate = unique.some(item => comparator(item, current))
-    // If no duplicate found, add current item to unique array
-    return hasDuplicate ? unique : [...unique, current]
-  }, [])
-}
-
-export function compact<T>(
-  array: (T | null | undefined)[] | null | undefined,
-): Exclude<T, null | undefined>[] {
-  const length = array === null || array === undefined ? 0 : array.length
-  let index = -1
-  let resIndex = 0
-  const result: Exclude<T, null | undefined>[] = []
-
-  while (index < length) {
-    index += 1
-    if (array !== null && array !== undefined) {
-      const value = array[index]
-
-      if (
-        value !== null &&
-        value !== undefined &&
-        value !== false &&
-        value !== 0 &&
-        value !== ''
-      ) {
-        result[resIndex] = value as Exclude<T, null | undefined>
-        resIndex += 1
-      }
-    }
-  }
-
-  return result
-}
-
-export function sumBy<T>(
-  array: T[] | null | undefined,
-  iteratee: ((value: T) => number) | keyof T,
-): number {
-  if (!array || !array.length) {
-    return 0
-  }
-
-  const getValue =
-    typeof iteratee === 'function'
-      ? iteratee
-      : (item: T) => item[iteratee] as unknown as number
-
-  let result: number | undefined = undefined
-  for (const item of array) {
-    const current = getValue(item)
-    if (current !== undefined) {
-      result = result === undefined ? current : result + current
-    }
-  }
-
-  return result ?? 0
-}
-
 type Iteratee<T> = ((item: T) => unknown) | keyof T
 type SortOrder = 'asc' | 'desc'
 

package/src/utils/sum-by.ts

@@ -0,0 +1,23 @@
+export function sumBy<T>(
+  array: T[] | null | undefined,
+  iteratee: ((value: T) => number) | keyof T,
+): number {
+  if (!array || !array.length) {
+    return 0
+  }
+
+  const getValue =
+    typeof iteratee === 'function'
+      ? iteratee
+      : (item: T) => item[iteratee] as unknown as number
+
+  let result: number | undefined = undefined
+  for (const item of array) {
+    const current = getValue(item)
+    if (current !== undefined) {
+      result = result === undefined ? current : result + current
+    }
+  }
+
+  return result ?? 0
+}

package/src/utils/uniq-with.ts

@@ -0,0 +1,16 @@
+type Comparator<T> = (a: T, b: T) => boolean
+
+export function uniqWith<T>(array: T[], comparator: Comparator<T>): T[] {
+  if (!Array.isArray(array) || typeof comparator !== 'function') {
+    throw new TypeError(
+      'First argument must be an array and second argument must be a function',
+    )
+  }
+
+  return array.reduce((unique: T[], current: T) => {
+    // Check if current item matches any existing item in unique array based on comparator
+    const hasDuplicate = unique.some(item => comparator(item, current))
+    // If no duplicate found, add current item to unique array
+    return hasDuplicate ? unique : [...unique, current]
+  }, [])
+}

package/src/utils/validators.ts

@@ -1,4 +1,3 @@
-/* @__PURE__ */
 export const validators = {
   alpha: (value: string): boolean => /[a-zA-Z]/u.test(value),
   email: (value: string): boolean => /.+@.+\..+/u.test(value),

package/src/utils/weighted-mean.ts

@@ -0,0 +1,9 @@
+export function weightedMean(values: number[], weights: number[]): number {
+  const sum = values.reduce(
+    (acc: number, val: number, i: number) => acc + val * (weights[i] ?? 0),
+    0,
+  )
+  const sumWeights = weights.reduce((acc: number, val: number) => acc + val, 0)
+
+  return sum / sumWeights
+}

package/src/utils/numbers.ts

@@ -1,46 +0,0 @@
-export function generateNumbersFromStr(str: string): [number, number] {
-  let hash = 5381
-  for (let i = 0; i < str.length; i++) {
-    // eslint-disable-next-line no-bitwise
-    hash = (hash << 5) + hash + str.charCodeAt(i)
-  }
-
-  // Generate two numbers using the hash
-  // eslint-disable-next-line no-bitwise
-  const num1 = (hash & 0xff_ff) / 0xff_ff
-  // eslint-disable-next-line no-bitwise
-  const num2 = ((hash >> 16) & 0xff_ff) / 0xff_ff
-
-  return [num1, num2]
-}
-
-export function randomInt(min: number, max: number): number {
-  return Math.floor(Math.random() * (max - min + 1) + min)
-}
-
-export function computeSellingPrice(
-  buyingPrice: number | string | null = 0,
-  rate: number | string | null = 0,
-): number {
-  if (Number.isNaN(Number(buyingPrice)) || Number.isNaN(Number(rate))) {
-    throw new TypeError('price or rate is NaN')
-  }
-
-  const sellingPrice = Number(buyingPrice) / (1 - Number(rate))
-
-  return Math.ceil(Math.floor(sellingPrice * 100) / 100)
-}
-
-export function computeMarginRate(
-  buyingPrice: number | string,
-  sellingPrice: number | string,
-): number {
-  const buyingPriceNum = Number(buyingPrice)
-  const sellingPriceNum = Number(sellingPrice)
-
-  if (Number.isNaN(sellingPriceNum) || Number.isNaN(buyingPriceNum)) {
-    throw new TypeError('sellingPrice or buyingPrice is NaN')
-  }
-
-  return Number((1 - buyingPriceNum / sellingPriceNum).toPrecision(10))
-}

package/src/utils/object-tools.ts

@@ -1,166 +0,0 @@
-import { isNil } from './value-tools.ts'
-
-// Utility type to merge T and S, allowing S to add/override properties in T
-type Merge<T, S> = {
-  [K in keyof T | keyof S]: K extends keyof S
-    ? S[K] extends object
-      ? K extends keyof T
-        ? T[K] extends object
-          ? Merge<T[K], S[K]>
-          : S[K]
-        : S[K]
-      : S[K]
-    : K extends keyof T
-      ? T[K]
-      : never
-}
-
-export function customMerge<T extends object, S extends object>(
-  target: T,
-  source: S,
-): Merge<T, S> {
-  for (const key of Object.keys(source)) {
-    const sourceValue = source[key as keyof S]
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const targetValue = (target as any)[key]
-
-    if (sourceValue !== undefined && sourceValue !== null) {
-      if (
-        targetValue &&
-        typeof targetValue === 'object' &&
-        !Array.isArray(targetValue) &&
-        typeof sourceValue === 'object' &&
-        !Array.isArray(sourceValue)
-      ) {
-        customMerge(targetValue as object, sourceValue as object)
-      } else {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        ;(target as any)[key] = sourceValue
-      }
-    }
-  }
-  return target as Merge<T, S>
-}
-
-export function pick<T extends object, K extends keyof T>(
-  obj: T,
-  keys: readonly K[],
-): Pick<T, K> {
-  const result = {} as Pick<T, K>
-  for (const key of keys) {
-    if (Object.hasOwn(obj, key)) {
-      result[key] = obj[key]
-    }
-  }
-  return result
-}
-
-export function compactObject<T extends object>(obj: T): Partial<T> {
-  return Object.fromEntries(
-    Object.entries(obj).filter(([, value]) => !isNil(value)),
-  ) as Partial<T>
-}
-
-/**
- * Creates an object composed of keys generated from the results of running each element of collection through iteratee.
- * The corresponding value of each key is the last element responsible for generating the key.
- *
- * @param collection - The collection to iterate over
- * @param iteratee - The iteratee to transform keys. Can be a function or a property name
- * @returns Returns the composed aggregate object
- */
-export function keyBy<T>(
-  collection: T[] | null | undefined,
-  iteratee: ((value: T) => string | number) | keyof T,
-): Record<string, T> {
-  return (
-    collection?.reduce<Record<string, T>>((acc, item) => {
-      if (item === undefined || item === null) {
-        return acc
-      }
-
-      const key =
-        typeof iteratee === 'function' ? iteratee(item) : String(item[iteratee])
-      acc[key] = item
-      return acc
-    }, {}) || {}
-  )
-}
-
-/**
- * Creates an object composed of the own enumerable properties of object that predicate doesn't return truthy for.
- * The predicate is invoked with two arguments: (value, key).
- * If predicate is a string, it omits the property with that key name.
- *
- * @param object - The source object
- * @param predicate - The function invoked per property or a string key to omit
- * @returns Returns the new object
- */
-export function omitBy<T extends object>(
-  object: T,
-  predicate: ((value: T[keyof T], key: keyof T) => boolean) | string,
-): Partial<T> {
-  const result = {} as Partial<T>
-
-  for (const key in object) {
-    if (Object.hasOwn(object, key)) {
-      const value = object[key]
-
-      // If predicate is a string, check if key matches
-      if (typeof predicate === 'string') {
-        // eslint-disable-next-line max-depth
-        if (key !== predicate) {
-          result[key] = value
-        }
-      } else if (typeof predicate === 'function') {
-        // If predicate is a function, use it
-        // eslint-disable-next-line max-depth
-        if (!predicate(value, key)) {
-          result[key] = value
-        }
-      }
-    }
-  }
-
-  return result
-}
-
-/**
- * Creates a shallow clone of `object` excluding the given own enumerable keys.
- * Accepts a single key or an array of keys. Symbol keys are supported.
- * If `object` is nullish, returns an empty object.
- */
-export function omit<T extends object, K extends keyof T>(
-  object: T | null | undefined,
-  keys: readonly K[] | K,
-): Omit<T, K> {
-  if (object === null || object === undefined) {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    return {} as any
-  }
-
-  const keysArray = (
-    Array.isArray(keys) ? keys : [keys]
-  ) as readonly (keyof T)[]
-  const keysSet = new Set<keyof T>(keysArray as (keyof T)[])
-
-  const result: Partial<T> = {}
-
-  // Copy string/number keys
-  for (const key in object) {
-    if (Object.hasOwn(object, key) && !keysSet.has(key as keyof T)) {
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      ;(result as any)[key] = object[key as keyof T]
-    }
-  }
-
-  // Copy symbol keys
-  for (const sym of Object.getOwnPropertySymbols(object)) {
-    if (!keysSet.has(sym as keyof T)) {
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      ;(result as any)[sym as unknown as keyof T] = (object as any)[sym]
-    }
-  }
-
-  return result as Omit<T, K>
-}