@revolugo/common 7.13.1-alpha.1 → 7.13.1-alpha.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@revolugo/common",
-  "version": "7.13.1-alpha.1",
+  "version": "7.13.1-alpha.10",
   "private": false,
   "description": "Revolugo common",
   "author": "Revolugo",

package/src/utils/case-transformer-core.ts

@@ -0,0 +1,72 @@
+import {
+  camelCase,
+  capitalCase,
+  kebabCase,
+  pascalCase,
+  snakeCase,
+} from 'change-case'
+import slugify from 'slugify'
+
+function slugCase(input: string): string {
+  return slugify(kebabCase(input), {
+    lower: true,
+    strict: true,
+  })
+}
+
+// eslint-disable-next-line @typescript-eslint/naming-convention -- public API constant object
+export const CaseTransformer = {
+  Camel: 'camelCase',
+  Capital: 'capitalCase',
+  Param: 'paramCase',
+  Pascal: 'pascalCase',
+  Slug: 'slugCase',
+  Snake: 'snakeCase',
+} as const
+
+export type CaseTransformer =
+  (typeof CaseTransformer)[keyof typeof CaseTransformer]
+
+export const CASE_TRANSFORMERS_MAPPING = {
+  [CaseTransformer.Camel]: camelCase,
+  [CaseTransformer.Capital]: capitalCase,
+  [CaseTransformer.Param]: kebabCase,
+  [CaseTransformer.Pascal]: pascalCase,
+  [CaseTransformer.Slug]: slugCase,
+  [CaseTransformer.Snake]: snakeCase,
+} as const
+
+export function changeCase<T extends string[] | string>(
+  input: T,
+  toCase: CaseTransformer,
+): T extends string ? string : string[] {
+  if (Array.isArray(input)) {
+    return input.map(item =>
+      CASE_TRANSFORMERS_MAPPING[toCase](item),
+    ) as T extends string ? string : string[]
+  }
+
+  return CASE_TRANSFORMERS_MAPPING[toCase](input) as T extends string
+    ? string
+    : string[]
+}
+
+export type PlainObject = Record<string, unknown>
+
+export function isPlainObject(value: unknown): value is PlainObject {
+  return (
+    value === Object(value) &&
+    !Array.isArray(value) &&
+    typeof value !== 'function'
+  )
+}
+
+export function matches(patterns: (RegExp | string)[], value: string): boolean {
+  return patterns.some(pattern =>
+    typeof pattern === 'string' ? pattern === value : pattern.test(value),
+  )
+}
+
+export function capitalize(value: string): string {
+  return value.replace(/^\w/u, character => character.toUpperCase())
+}

package/src/utils/case-transformer.test.ts

@@ -0,0 +1,73 @@
+/* eslint-disable camelcase -- fixture keys intentionally use snake_case */
+import { describe, expect, test } from 'vitest'
+
+import { CaseTransformer } from './case-transformer-core.ts'
+import { keysCaseTransformer, keysChangeCase } from './keys-case-transformer.ts'
+
+describe('keysCaseTransformer', () => {
+  test('transforms keys shallowly by default', () => {
+    const input = { nested_object: { inner_key: 1 }, top_level: true }
+
+    expect(keysCaseTransformer(input, CaseTransformer.Camel)).toEqual({
+      nestedObject: { inner_key: 1 },
+      topLevel: true,
+    })
+  })
+
+  test('transforms keys deeply when requested', () => {
+    const input = { nested_object: { inner_key: 1 } }
+
+    expect(
+      keysCaseTransformer(input, CaseTransformer.Camel, { deep: true }),
+    ).toEqual({
+      nestedObject: { innerKey: 1 },
+    })
+  })
+
+  test('keeps excluded keys unchanged', () => {
+    const input = { keep_me: 1, transform_me: 2 }
+
+    expect(
+      keysCaseTransformer(input, CaseTransformer.Camel, {
+        deep: true,
+        exclude: [/^keep_me$/u],
+      }),
+    ).toEqual({
+      keep_me: 1,
+      transformMe: 2,
+    })
+  })
+
+  test('skips Date instances', () => {
+    const date = new Date('2026-01-01T00:00:00.000Z')
+    const input = { created_at: date }
+
+    expect(
+      keysCaseTransformer(input, CaseTransformer.Camel, { deep: true }),
+    ).toEqual({
+      createdAt: date,
+    })
+  })
+})
+
+describe('keysChangeCase', () => {
+  test('defaults to deep transformation for backward compatibility', () => {
+    const input = { nested_object: { inner_key: 1 } }
+
+    expect(keysChangeCase(input, CaseTransformer.Camel)).toEqual({
+      nestedObject: { innerKey: 1 },
+    })
+  })
+
+  test('matches keysCaseTransformer for deep snake_case transforms', () => {
+    const input = {
+      hotel_room_offer: {
+        booking_policy: { cancel_until: '2026-06-10' },
+      },
+    }
+
+    expect(keysChangeCase(input, CaseTransformer.Snake)).toEqual(
+      keysCaseTransformer(input, CaseTransformer.Snake, { deep: true }),
+    )
+  })
+})

package/src/utils/case-transformers.ts

@@ -1,108 +1,11 @@
-import {
-  camelCase,
-  capitalCase,
-  kebabCase,
-  pascalCase,
-  snakeCase,
-} from 'change-case'
-import slugify from 'slugify'
-
-function slugCase(input: string): string {
-  return slugify(kebabCase(input), {
-    lower: true,
-    strict: true,
-  })
-}
-
-export enum CaseTransformer {
-  Camel = 'camelCase',
-  Capital = 'capitalCase',
-  Param = 'paramCase',
-  Pascal = 'pascalCase',
-  Slug = 'slugCase',
-  Snake = 'snakeCase',
-}
-
-export const CASE_TRANSFORMERS_MAPPING = {
-  [CaseTransformer.Camel]: camelCase,
-  [CaseTransformer.Capital]: capitalCase,
-  [CaseTransformer.Param]: kebabCase,
-  [CaseTransformer.Pascal]: pascalCase,
-  [CaseTransformer.Slug]: slugCase,
-  [CaseTransformer.Snake]: snakeCase,
-}
-
-export function changeCase<T extends string[] | string>(
-  input: T,
-  toCase: CaseTransformer,
-): T extends string ? string : string[] {
-  if (Array.isArray(input)) {
-    return input.map(item =>
-      CASE_TRANSFORMERS_MAPPING[toCase](item),
-    ) as T extends string ? string : string[]
-  }
-
-  return CASE_TRANSFORMERS_MAPPING[toCase](input) as T extends string
-    ? string
-    : string[]
-}
-
-function matches(patterns: (RegExp | string)[], value: string) {
-  return patterns.some(pattern =>
-    typeof pattern === 'string' ? pattern === value : pattern.test(value),
-  )
-}
-
-type PlainObject = Record<string, unknown>
-
-function isPlainObject(value: unknown): value is PlainObject {
-  return (
-    value === Object(value) &&
-    !Array.isArray(value) &&
-    typeof value !== 'function'
-  )
-}
-
-/** Infer `T` from input, or set `T` explicitly when output type differs (e.g. fixture → domain). */
-export function keysChangeCase<T extends object | readonly unknown[]>(
-  obj: T | object | readonly unknown[],
-  toCase: CaseTransformer,
-  options?: { deep?: boolean; exclude?: (RegExp | string)[] },
-): T
-
-/** Unknown input — `Record<string, unknown>` / `unknown[]` instead of `unknown`. */
-export function keysChangeCase(
-  obj: unknown,
-  toCase: CaseTransformer,
-  options?: { deep?: boolean; exclude?: (RegExp | string)[] },
-): PlainObject | unknown[]
-
-export function keysChangeCase(
-  obj: unknown,
-  toCase: CaseTransformer,
-  options: { deep?: boolean; exclude?: (RegExp | string)[] } = { deep: true },
-): PlainObject | unknown[] | unknown {
-  if (isPlainObject(obj) && !(obj instanceof Date)) {
-    return Object.keys(obj).reduce<PlainObject>((result, key) => {
-      // Check if key should be excluded from the transformation
-      const transformedKey =
-        options?.exclude && matches(options.exclude, key)
-          ? key
-          : CASE_TRANSFORMERS_MAPPING[toCase](key)
-
-      result[transformedKey] = options.deep
-        ? keysChangeCase(obj[key], toCase, options)
-        : obj[key]
-
-      return result
-    }, {})
-  } else if (Array.isArray(obj)) {
-    return obj.map(item => keysChangeCase(item, toCase, options))
-  }
-
-  return obj
-}
-
-export function capitalize(value: string): string {
-  return value.replace(/^\w/u, c => c.toUpperCase())
-}
+export {
+  CASE_TRANSFORMERS_MAPPING,
+  CaseTransformer,
+  capitalize,
+  changeCase,
+  isPlainObject,
+  matches,
+  type PlainObject,
+} from './case-transformer-core.ts'
+
+export { keysChangeCase, keysCaseTransformer } from './keys-case-transformer.ts'

package/src/utils/index.ts

@@ -35,7 +35,6 @@ export * from './is-equal.ts'
 export * from './is-nil.ts'
 export * from './is-object.ts'
 export * from './key-by.ts'
-export * from './keys-case-transformer.ts'
 export * from './lang-default-fallbacks.ts'
 export * from './map-keys.ts'
 export * from './map-values.ts'
@@ -43,6 +42,7 @@ export * from './merge.ts'
 export * from './omit-by.ts'
 export * from './omit.ts'
 export * from './parse-children.ts'
+export * from './pick-by.ts'
 export * from './pick.ts'
 export * from './poller.ts'
 export * from './prepare-ts-query.ts'

package/src/utils/keys-case-transformer.ts

@@ -1,7 +1,6 @@
-import { type CaseTransformer, changeCase } from './case-transformers.ts'
-import { isObject } from './is-object.ts'
-import { mapKeys } from './map-keys.ts'
+import { changeCase, isPlainObject, matches } from './case-transformer-core.ts'
 
+import type { CaseTransformer, PlainObject } from './case-transformer-core.ts'
 import type {
   CamelCasedProperties,
   CamelCasedPropertiesDeep,
@@ -13,46 +12,32 @@ import type {
   SnakeCasedPropertiesDeep,
 } from 'type-fest'
 
-/**
- * Maps CaseTransformer enum to the corresponding type-fest property transformation (shallow).
- * Capital and Slug cases don't have type-fest equivalents, so they preserve the original type.
- */
 type TransformProperties<
   T,
   C extends CaseTransformer,
-> = C extends CaseTransformer.Camel
+> = C extends typeof CaseTransformer.Camel
   ? CamelCasedProperties<T>
-  : C extends CaseTransformer.Snake
+  : C extends typeof CaseTransformer.Snake
     ? SnakeCasedProperties<T>
-    : C extends CaseTransformer.Pascal
+    : C extends typeof CaseTransformer.Pascal
       ? PascalCasedProperties<T>
-      : C extends CaseTransformer.Param
+      : C extends typeof CaseTransformer.Param
         ? KebabCasedProperties<T>
         : T
 
-/**
- * Maps CaseTransformer enum to the corresponding type-fest deep property transformation.
- * Capital and Slug cases don't have type-fest equivalents, so they preserve the original type.
- */
 type TransformPropertiesDeep<
   T,
   C extends CaseTransformer,
-> = C extends CaseTransformer.Camel
+> = C extends typeof CaseTransformer.Camel
   ? CamelCasedPropertiesDeep<T>
-  : C extends CaseTransformer.Snake
+  : C extends typeof CaseTransformer.Snake
     ? SnakeCasedPropertiesDeep<T>
-    : C extends CaseTransformer.Pascal
+    : C extends typeof CaseTransformer.Pascal
       ? PascalCasedPropertiesDeep<T>
-      : C extends CaseTransformer.Param
+      : C extends typeof CaseTransformer.Param
         ? KebabCasedPropertiesDeep<T>
         : T
 
-/**
- * Transforms object keys based on the specified case transformer.
- * - Arrays: recursively applies transformation to each element
- * - Objects: applies property transformation (shallow by default, deep if Deep=true)
- * - Primitives: returns as-is
- */
 export type KeysCaseTransformed<
   T,
   C extends CaseTransformer,
@@ -71,48 +56,86 @@ export type KeysCaseTransformed<
 
 export interface KeysCaseTransformerOptions {
   deep?: boolean
+  exclude?: (RegExp | string)[]
+}
+
+function keysCaseTransformerImpl(
+  obj: unknown,
+  toCase: CaseTransformer,
+  options: KeysCaseTransformerOptions,
+): unknown {
+  const deep = options.deep ?? false
+
+  if (Array.isArray(obj)) {
+    return obj.map(item => keysCaseTransformerImpl(item, toCase, options))
+  }
+
+  if (isPlainObject(obj) && !(obj instanceof Date)) {
+    return Object.keys(obj).reduce<PlainObject>((accumulator, key) => {
+      const transformedKey =
+        options.exclude && matches(options.exclude, key)
+          ? key
+          : changeCase(key, toCase)
+
+      accumulator[transformedKey] = deep
+        ? keysCaseTransformerImpl(obj[key], toCase, {
+            ...options,
+            deep: true,
+          })
+        : obj[key]
+
+      return accumulator
+    }, {})
+  }
+
+  return obj
 }
 
-// Overload: deep transformation
 export function keysCaseTransformer<T, C extends CaseTransformer>(
   obj: T,
   toCase: C,
-  options: { deep: true },
+  options: KeysCaseTransformerOptions & { deep: true },
 ): KeysCaseTransformed<T, C, true>
 
-// Overload: shallow transformation (default)
 export function keysCaseTransformer<T, C extends CaseTransformer>(
   obj: T,
   toCase: C,
-  options?: { deep?: false },
+  options?: KeysCaseTransformerOptions & { deep?: false },
 ): KeysCaseTransformed<T, C>
 
-// Implementation
 export function keysCaseTransformer<T, C extends CaseTransformer>(
   obj: T,
   toCase: C,
-  options?: KeysCaseTransformerOptions,
+  options: KeysCaseTransformerOptions = {},
 ): KeysCaseTransformed<T, C, boolean> {
-  if (Array.isArray(obj)) {
-    return obj.map(item =>
-      keysCaseTransformer(item, toCase, options as { deep: true }),
-    ) as KeysCaseTransformed<T, C, boolean>
-  }
+  return keysCaseTransformerImpl(obj, toCase, options) as KeysCaseTransformed<
+    T,
+    C,
+    boolean
+  >
+}
 
-  if (isObject(obj)) {
-    const transformed = mapKeys(obj, key => changeCase(key, toCase))
-    if (options?.deep) {
-      // Recursively transform nested values
-      return Object.fromEntries(
-        Object.entries(transformed).map(([k, v]) => [
-          k,
-          keysCaseTransformer(v, toCase, options as { deep: true }),
-        ]),
-      ) as KeysCaseTransformed<T, C, boolean>
-    }
-
-    return transformed as KeysCaseTransformed<T, C, boolean>
-  }
+/** Backward-compatible wrapper defaulting to deep transforms. */
+export function keysChangeCase<T extends object | readonly unknown[]>(
+  obj: T | object | readonly unknown[],
+  toCase: CaseTransformer,
+  options?: KeysCaseTransformerOptions,
+): T
+
+/** Unknown input — `Record<string, unknown>` / `unknown[]` instead of `unknown`. */
+export function keysChangeCase(
+  obj: unknown,
+  toCase: CaseTransformer,
+  options?: KeysCaseTransformerOptions,
+): PlainObject | unknown[]
 
-  return obj as KeysCaseTransformed<T, C, boolean>
+export function keysChangeCase(
+  obj: unknown,
+  toCase: CaseTransformer,
+  options: KeysCaseTransformerOptions = {},
+): PlainObject | unknown[] | unknown {
+  return keysCaseTransformerImpl(obj, toCase, {
+    deep: options.deep ?? true,
+    exclude: options.exclude,
+  })
 }

package/src/utils/pick-by.ts

@@ -0,0 +1,37 @@
+/**
+ * Creates an object composed of the own enumerable properties of object that predicate returns truthy for.
+ * The predicate is invoked with two arguments: (value, key).
+ * If predicate is a string, it picks the property with that key name.
+ *
+ * @param object - The source object
+ * @param predicate - The function invoked per property or a string key to pick
+ * @returns Returns the new object
+ */
+export function pickBy<T extends object>(
+  object: T,
+  predicate: string | ((value: T[keyof T], key: keyof T) => boolean),
+): 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/sum-by.ts

@@ -6,10 +6,13 @@ export function sumBy<T>(
     return 0
   }
 
-  const getValue =
+  const getValue: (item: T) => number | undefined =
     typeof iteratee === 'function'
       ? iteratee
-      : (item: T) => item[iteratee] as unknown as number
+      : (item: T) => {
+          const value = item[iteratee]
+          return typeof value === 'number' ? value : undefined
+        }
 
   let result: number | undefined = undefined
   for (const item of array) {