Snake & Camel cases conversors

snake-camel.ts

77 
export type RemoveUnderscoreFirstLetter<S extends string> =
  S extends `${infer FirstLetter}${infer U}`
    ? `${FirstLetter extends '_' ? U : `${FirstLetter}${U}`}`
    : S;

export type CamelToSnakeCase<S extends string> =
  S extends `${infer T}${infer U}`
    ? `${T extends Capitalize<T> ? '_' : ''}${RemoveUnderscoreFirstLetter<
        Lowercase<T>
      >}${CamelToSnakeCase<U>}`
    : S;

export type SnakeToCamelCase<S extends string> =
  S extends `${infer T}_${infer U}`
    ? `${T}${SnakeToCamelCase<Capitalize<U>>}`
    : S;

export type KeysToSnakeCase<T extends object> = {
  [K in keyof T as CamelToSnakeCase<K & string>]: T[K];
};

export type KeysToCamelCase<T extends object> = {
  [K in keyof T as SnakeToCamelCase<K & string>]: T[K];
};

function toCamelCase(str: string): string {
  return str.replace(/([-_][a-z])/g, (group) =>
    group.toUpperCase().replace('-', '').replace('_', '')
  );
}

export function toCamelCaseObject<T extends object>(
  obj: T
): KeysToCamelCase<T> {
  const newObj: any = {};
  for (const key in obj) {
    newObj[toCamelCase(key)] = obj[key];
  }
  return newObj as KeysToCamelCase<T>;
}

import { KeysToSnakeCase } from './types.ts';

function toSnakeCase(str: string): string {
  return str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
}

export function toSnakeCaseObject<T extends object>(
  obj: T
): KeysToSnakeCase<T> {
  const newObj: any = {};
  for (const key in obj) {
    newObj[toSnakeCase(key)] = obj[key];
  }
  return newObj as KeysToSnakeCase<T>;
}