goodchuck-utils 1.2.0 → 1.3.0

package/src/string/__tests__/validation.test.ts

@@ -0,0 +1,128 @@
+import { describe, it, expect } from 'vitest';
+import {
+  isEmpty,
+  startsWith,
+  endsWith,
+  contains,
+  isAlpha,
+  isNumeric,
+  isAlphanumeric,
+  isLowerCase,
+  isUpperCase,
+  isJSON,
+  isHexColor,
+  isUUID,
+  isBase64,
+} from '../validation';
+
+describe('String Validation', () => {
+  describe('isEmpty', () => {
+    it('should detect empty strings', () => {
+      expect(isEmpty('')).toBe(true);
+      expect(isEmpty('   ')).toBe(true);
+      expect(isEmpty('hello')).toBe(false);
+    });
+  });
+
+  describe('startsWith', () => {
+    it('should check if string starts with substring', () => {
+      expect(startsWith('hello', 'he')).toBe(true);
+      expect(startsWith('hello', 'ho')).toBe(false);
+    });
+  });
+
+  describe('endsWith', () => {
+    it('should check if string ends with substring', () => {
+      expect(endsWith('hello', 'lo')).toBe(true);
+      expect(endsWith('hello', 'he')).toBe(false);
+    });
+  });
+
+  describe('contains', () => {
+    it('should check if string contains substring', () => {
+      expect(contains('hello world', 'world')).toBe(true);
+      expect(contains('hello world', 'foo')).toBe(false);
+    });
+  });
+
+  describe('isAlpha', () => {
+    it('should validate alphabetic strings', () => {
+      expect(isAlpha('hello')).toBe(true);
+      expect(isAlpha('Hello')).toBe(true);
+      expect(isAlpha('hello123')).toBe(false);
+      expect(isAlpha('hello_world')).toBe(false);
+    });
+  });
+
+  describe('isNumeric', () => {
+    it('should validate numeric strings', () => {
+      expect(isNumeric('123')).toBe(true);
+      expect(isNumeric('123.45')).toBe(false);
+      expect(isNumeric('abc')).toBe(false);
+    });
+  });
+
+  describe('isAlphanumeric', () => {
+    it('should validate alphanumeric strings', () => {
+      expect(isAlphanumeric('hello123')).toBe(true);
+      expect(isAlphanumeric('hello')).toBe(true);
+      expect(isAlphanumeric('123')).toBe(true);
+      expect(isAlphanumeric('hello_123')).toBe(false);
+      expect(isAlphanumeric('hello-123')).toBe(false);
+    });
+  });
+
+  describe('isLowerCase', () => {
+    it('should detect lowercase strings', () => {
+      expect(isLowerCase('hello')).toBe(true);
+      expect(isLowerCase('Hello')).toBe(false);
+      expect(isLowerCase('HELLO')).toBe(false);
+    });
+  });
+
+  describe('isUpperCase', () => {
+    it('should detect uppercase strings', () => {
+      expect(isUpperCase('HELLO')).toBe(true);
+      expect(isUpperCase('Hello')).toBe(false);
+      expect(isUpperCase('hello')).toBe(false);
+    });
+  });
+
+  describe('isJSON', () => {
+    it('should validate JSON strings', () => {
+      expect(isJSON('{"name":"John"}')).toBe(true);
+      expect(isJSON('[1,2,3]')).toBe(true);
+      expect(isJSON('"hello"')).toBe(true);
+      expect(isJSON('not json')).toBe(false);
+      expect(isJSON('{invalid}')).toBe(false);
+    });
+  });
+
+  describe('isHexColor', () => {
+    it('should validate hex color codes', () => {
+      expect(isHexColor('#fff')).toBe(true);
+      expect(isHexColor('#ffffff')).toBe(true);
+      expect(isHexColor('#FFF')).toBe(true);
+      expect(isHexColor('#ABC123')).toBe(true);
+      expect(isHexColor('fff')).toBe(false);
+      expect(isHexColor('#gggggg')).toBe(false);
+    });
+  });
+
+  describe('isUUID', () => {
+    it('should validate UUID strings', () => {
+      expect(isUUID('123e4567-e89b-12d3-a456-426614174000')).toBe(true);
+      expect(isUUID('550e8400-e29b-41d4-a716-446655440000')).toBe(true);
+      expect(isUUID('not-a-uuid')).toBe(false);
+      expect(isUUID('123e4567-e89b-12d3')).toBe(false);
+    });
+  });
+
+  describe('isBase64', () => {
+    it('should validate base64 strings', () => {
+      expect(isBase64('SGVsbG8gV29ybGQ=')).toBe(true);
+      expect(isBase64('dGVzdA==')).toBe(true);
+      expect(isBase64('not base64')).toBe(false);
+    });
+  });
+});

package/src/string/case.ts

@@ -0,0 +1,76 @@
+/**
+ * String Case Conversion Utilities
+ */
+
+/**
+ * 첫 글자를 대문자로 변환
+ * @example capitalize('hello world') // 'Hello world'
+ */
+export function capitalize(str: string): string {
+  if (!str) return str;
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+
+/**
+ * 모든 단어의 첫 글자를 대문자로 변환
+ * @example capitalizeWords('hello world') // 'Hello World'
+ */
+export function capitalizeWords(str: string): string {
+  if (!str) return str;
+  return str.replace(/\b\w/g, (char) => char.toUpperCase());
+}
+
+/**
+ * camelCase로 변환
+ * @example camelCase('hello world') // 'helloWorld'
+ * @example camelCase('hello-world') // 'helloWorld'
+ */
+export function camelCase(str: string): string {
+  return str
+    .toLowerCase()
+    .replace(/[^a-zA-Z0-9]+(.)/g, (_, char) => char.toUpperCase());
+}
+
+/**
+ * PascalCase로 변환
+ * @example pascalCase('hello world') // 'HelloWorld'
+ */
+export function pascalCase(str: string): string {
+  return capitalize(camelCase(str));
+}
+
+/**
+ * snake_case로 변환
+ * @example snakeCase('helloWorld') // 'hello_world'
+ * @example snakeCase('Hello World') // 'hello_world'
+ */
+export function snakeCase(str: string): string {
+  return str
+    .replace(/([A-Z])/g, '_$1')
+    .replace(/[\s-]+/g, '_')
+    .replace(/_+/g, '_')
+    .replace(/^_/, '')
+    .toLowerCase();
+}
+
+/**
+ * kebab-case로 변환
+ * @example kebabCase('helloWorld') // 'hello-world'
+ * @example kebabCase('Hello World') // 'hello-world'
+ */
+export function kebabCase(str: string): string {
+  return str
+    .replace(/([A-Z])/g, '-$1')
+    .replace(/[\s_]+/g, '-')
+    .replace(/-+/g, '-')
+    .replace(/^-/, '')
+    .toLowerCase();
+}
+
+/**
+ * CONSTANT_CASE로 변환
+ * @example constantCase('helloWorld') // 'HELLO_WORLD'
+ */
+export function constantCase(str: string): string {
+  return snakeCase(str).toUpperCase();
+}

package/src/string/index.ts

@@ -0,0 +1,14 @@
+/**
+ * String Utilities
+ *
+ * This module provides utilities for string case conversion, manipulation, and validation.
+ */
+
+// Case conversion utilities
+export * from './case';
+
+// Manipulation utilities
+export * from './manipulation';
+
+// Validation utilities
+export * from './validation';

package/src/string/manipulation.ts

@@ -0,0 +1,124 @@
+/**
+ * String Manipulation Utilities
+ */
+
+/**
+ * 문자열을 지정된 길이로 자르고 말줄임표 추가
+ * @example truncate('Hello World', 5) // 'Hello...'
+ */
+export function truncate(str: string, length: number, suffix: string = '...'): string {
+  if (str.length <= length) return str;
+  return str.slice(0, length) + suffix;
+}
+
+/**
+ * 문자열 양쪽 공백 제거 및 연속된 공백을 하나로
+ * @example normalizeWhitespace('  hello   world  ') // 'hello world'
+ */
+export function normalizeWhitespace(str: string): string {
+  return str.trim().replace(/\s+/g, ' ');
+}
+
+/**
+ * URL 친화적인 슬러그 생성
+ * @example slugify('Hello World!') // 'hello-world'
+ * @example slugify('Test123 World') // 'test123-world'
+ */
+export function slugify(str: string): string {
+  return str
+    .toLowerCase()
+    .trim()
+    .replace(/[^\w\s-]/g, '')
+    .replace(/[\s_]+/g, '-')
+    .replace(/-+/g, '-')
+    .replace(/^-+|-+$/g, '');
+}
+
+/**
+ * 랜덤 문자열 생성
+ * @param length - 생성할 문자열 길이
+ * @param charset - 사용할 문자 집합 ('alphanumeric', 'alpha', 'numeric', 'hex')
+ */
+export function randomString(
+  length: number,
+  charset: 'alphanumeric' | 'alpha' | 'numeric' | 'hex' = 'alphanumeric'
+): string {
+  const charsets = {
+    alphanumeric: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789',
+    alpha: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz',
+    numeric: '0123456789',
+    hex: '0123456789abcdef',
+  };
+
+  const chars = charsets[charset];
+  let result = '';
+
+  for (let i = 0; i < length; i++) {
+    result += chars.charAt(Math.floor(Math.random() * chars.length));
+  }
+
+  return result;
+}
+
+/**
+ * 문자열 반복
+ * @example repeat('ab', 3) // 'ababab'
+ */
+export function repeat(str: string, count: number): string {
+  return str.repeat(count);
+}
+
+/**
+ * 문자열 뒤집기
+ * @example reverse('hello') // 'olleh'
+ */
+export function reverse(str: string): string {
+  return str.split('').reverse().join('');
+}
+
+/**
+ * 문자열에서 HTML 태그 제거
+ * @example stripHtml('<p>Hello <strong>World</strong></p>') // 'Hello World'
+ */
+export function stripHtml(str: string): string {
+  return str.replace(/<[^>]*>/g, '');
+}
+
+/**
+ * 문자열을 특정 길이로 패딩
+ * @example padStart('5', 3, '0') // '005'
+ */
+export function padStart(str: string, length: number, fillString: string = ' '): string {
+  return str.padStart(length, fillString);
+}
+
+/**
+ * 문자열을 특정 길이로 패딩 (오른쪽)
+ * @example padEnd('5', 3, '0') // '500'
+ */
+export function padEnd(str: string, length: number, fillString: string = ' '): string {
+  return str.padEnd(length, fillString);
+}
+
+/**
+ * 템플릿 문자열 치환
+ * @example template('Hello {name}!', { name: 'World' }) // 'Hello World!'
+ */
+export function template(str: string, values: Record<string, any>): string {
+  return str.replace(/\{(\w+)\}/g, (match, key) => {
+    return values[key] !== undefined ? String(values[key]) : match;
+  });
+}
+
+/**
+ * 마스킹 (특정 위치의 문자를 *로 변경)
+ * @example mask('1234567890', 3, 7) // '123****890'
+ */
+export function mask(str: string, start: number, end?: number, maskChar: string = '*'): string {
+  const endPos = end ?? str.length;
+  return (
+    str.slice(0, start) +
+    maskChar.repeat(endPos - start) +
+    str.slice(endPos)
+  );
+}

package/src/string/validation.ts

@@ -0,0 +1,126 @@
+/**
+ * String Validation Utilities
+ */
+
+/**
+ * 빈 문자열 또는 공백만 있는지 확인
+ * @example isEmpty('') // true
+ * @example isEmpty('  ') // true
+ * @example isEmpty('hello') // false
+ */
+export function isEmpty(str: string): boolean {
+  return !str || str.trim().length === 0;
+}
+
+/**
+ * 문자열이 특정 문자로 시작하는지 확인
+ * @example startsWith('hello', 'he') // true
+ */
+export function startsWith(str: string, searchString: string): boolean {
+  return str.startsWith(searchString);
+}
+
+/**
+ * 문자열이 특정 문자로 끝나는지 확인
+ * @example endsWith('hello', 'lo') // true
+ */
+export function endsWith(str: string, searchString: string): boolean {
+  return str.endsWith(searchString);
+}
+
+/**
+ * 문자열에 특정 문자열이 포함되어 있는지 확인
+ * @example contains('hello world', 'world') // true
+ */
+export function contains(str: string, searchString: string): boolean {
+  return str.includes(searchString);
+}
+
+/**
+ * 알파벳만 포함하는지 확인
+ * @example isAlpha('hello') // true
+ * @example isAlpha('hello123') // false
+ */
+export function isAlpha(str: string): boolean {
+  return /^[a-zA-Z]+$/.test(str);
+}
+
+/**
+ * 숫자만 포함하는지 확인
+ * @example isNumeric('123') // true
+ * @example isNumeric('123.45') // false
+ */
+export function isNumeric(str: string): boolean {
+  return /^[0-9]+$/.test(str);
+}
+
+/**
+ * 알파벳과 숫자만 포함하는지 확인
+ * @example isAlphanumeric('hello123') // true
+ * @example isAlphanumeric('hello_123') // false
+ */
+export function isAlphanumeric(str: string): boolean {
+  return /^[a-zA-Z0-9]+$/.test(str);
+}
+
+/**
+ * 소문자만 포함하는지 확인
+ * @example isLowerCase('hello') // true
+ * @example isLowerCase('Hello') // false
+ */
+export function isLowerCase(str: string): boolean {
+  return str === str.toLowerCase() && str !== str.toUpperCase();
+}
+
+/**
+ * 대문자만 포함하는지 확인
+ * @example isUpperCase('HELLO') // true
+ * @example isUpperCase('Hello') // false
+ */
+export function isUpperCase(str: string): boolean {
+  return str === str.toUpperCase() && str !== str.toLowerCase();
+}
+
+/**
+ * JSON 형식인지 확인
+ * @example isJSON('{"name":"John"}') // true
+ * @example isJSON('not json') // false
+ */
+export function isJSON(str: string): boolean {
+  try {
+    JSON.parse(str);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * 16진수 색상 코드인지 확인
+ * @example isHexColor('#fff') // true
+ * @example isHexColor('#ffffff') // true
+ * @example isHexColor('fff') // false
+ */
+export function isHexColor(str: string): boolean {
+  return /^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})$/.test(str);
+}
+
+/**
+ * UUID 형식인지 확인
+ * @example isUUID('123e4567-e89b-12d3-a456-426614174000') // true
+ */
+export function isUUID(str: string): boolean {
+  return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(str);
+}
+
+/**
+ * Base64 인코딩된 문자열인지 확인
+ * @example isBase64('SGVsbG8gV29ybGQ=') // true
+ */
+export function isBase64(str: string): boolean {
+  try {
+    return btoa(atob(str)) === str;
+  } catch {
+    return false;
+  }
+}