goodchuck-utils 1.2.0 → 1.3.0

package/dist/string/__tests__/manipulation.test.js

@@ -0,0 +1,109 @@
+import { describe, it, expect } from 'vitest';
+import { truncate, normalizeWhitespace, slugify, randomString, repeat, reverse, stripHtml, padStart, padEnd, template, mask, } from '../manipulation';
+describe('String Manipulation', () => {
+    describe('truncate', () => {
+        it('should truncate long strings', () => {
+            expect(truncate('Hello World', 5)).toBe('Hello...');
+            expect(truncate('Hello World', 20)).toBe('Hello World');
+        });
+        it('should use custom suffix', () => {
+            expect(truncate('Hello World', 5, '---')).toBe('Hello---');
+        });
+    });
+    describe('normalizeWhitespace', () => {
+        it('should normalize whitespace', () => {
+            expect(normalizeWhitespace('  hello   world  ')).toBe('hello world');
+            expect(normalizeWhitespace('hello\n\nworld')).toBe('hello world');
+        });
+    });
+    describe('slugify', () => {
+        it('should create URL-friendly slugs', () => {
+            expect(slugify('Hello World!')).toBe('hello-world');
+            expect(slugify('Hello   World')).toBe('hello-world');
+            expect(slugify('Hello_World')).toBe('hello-world');
+        });
+        it('should preserve alphanumeric characters', () => {
+            expect(slugify('Test123 World')).toBe('test123-world');
+        });
+        it('should remove special characters', () => {
+            expect(slugify('Hello @#$ World!')).toBe('hello-world');
+        });
+    });
+    describe('randomString', () => {
+        it('should generate random alphanumeric string', () => {
+            const result = randomString(10);
+            expect(result).toHaveLength(10);
+            expect(/^[a-zA-Z0-9]+$/.test(result)).toBe(true);
+        });
+        it('should generate numeric only string', () => {
+            const result = randomString(10, 'numeric');
+            expect(result).toHaveLength(10);
+            expect(/^[0-9]+$/.test(result)).toBe(true);
+        });
+        it('should generate alpha only string', () => {
+            const result = randomString(10, 'alpha');
+            expect(result).toHaveLength(10);
+            expect(/^[a-zA-Z]+$/.test(result)).toBe(true);
+        });
+        it('should generate hex string', () => {
+            const result = randomString(10, 'hex');
+            expect(result).toHaveLength(10);
+            expect(/^[0-9a-f]+$/.test(result)).toBe(true);
+        });
+    });
+    describe('repeat', () => {
+        it('should repeat string', () => {
+            expect(repeat('ab', 3)).toBe('ababab');
+            expect(repeat('x', 5)).toBe('xxxxx');
+        });
+    });
+    describe('reverse', () => {
+        it('should reverse string', () => {
+            expect(reverse('hello')).toBe('olleh');
+            expect(reverse('12345')).toBe('54321');
+        });
+    });
+    describe('stripHtml', () => {
+        it('should remove HTML tags', () => {
+            expect(stripHtml('<p>Hello</p>')).toBe('Hello');
+            expect(stripHtml('<p>Hello <strong>World</strong></p>')).toBe('Hello World');
+            expect(stripHtml('No tags here')).toBe('No tags here');
+        });
+    });
+    describe('padStart', () => {
+        it('should pad string at start', () => {
+            expect(padStart('5', 3, '0')).toBe('005');
+            expect(padStart('abc', 5, 'x')).toBe('xxabc');
+        });
+    });
+    describe('padEnd', () => {
+        it('should pad string at end', () => {
+            expect(padEnd('5', 3, '0')).toBe('500');
+            expect(padEnd('abc', 5, 'x')).toBe('abcxx');
+        });
+    });
+    describe('template', () => {
+        it('should replace placeholders', () => {
+            expect(template('Hello {name}!', { name: 'World' })).toBe('Hello World!');
+            expect(template('I am {age} years old', { age: 25 })).toBe('I am 25 years old');
+        });
+        it('should keep unreplaced placeholders', () => {
+            expect(template('Hello {name}!', {})).toBe('Hello {name}!');
+        });
+        it('should handle multiple placeholders', () => {
+            expect(template('{greeting} {name}!', { greeting: 'Hi', name: 'John' })).toBe('Hi John!');
+        });
+    });
+    describe('mask', () => {
+        it('should mask characters', () => {
+            expect(mask('1234567890', 3, 7)).toBe('123****890');
+            expect(mask('password', 2, 6)).toBe('pa****rd');
+        });
+        it('should use custom mask character', () => {
+            expect(mask('1234567890', 3, 7, 'x')).toBe('123xxxx890');
+        });
+        it('should mask to end if end not specified', () => {
+            expect(mask('1234567890', 5)).toBe('12345*****');
+        });
+    });
+});

package/dist/string/__tests__/validation.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=validation.test.d.ts.map

package/dist/string/__tests__/validation.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation.test.d.ts","sourceRoot":"","sources":["../../../src/string/__tests__/validation.test.ts"],"names":[],"mappings":""}

package/dist/string/__tests__/validation.test.js

@@ -0,0 +1,101 @@
+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/dist/string/case.d.ts

@@ -0,0 +1,42 @@
+/**
+ * String Case Conversion Utilities
+ */
+/**
+ * 첫 글자를 대문자로 변환
+ * @example capitalize('hello world') // 'Hello world'
+ */
+export declare function capitalize(str: string): string;
+/**
+ * 모든 단어의 첫 글자를 대문자로 변환
+ * @example capitalizeWords('hello world') // 'Hello World'
+ */
+export declare function capitalizeWords(str: string): string;
+/**
+ * camelCase로 변환
+ * @example camelCase('hello world') // 'helloWorld'
+ * @example camelCase('hello-world') // 'helloWorld'
+ */
+export declare function camelCase(str: string): string;
+/**
+ * PascalCase로 변환
+ * @example pascalCase('hello world') // 'HelloWorld'
+ */
+export declare function pascalCase(str: string): string;
+/**
+ * snake_case로 변환
+ * @example snakeCase('helloWorld') // 'hello_world'
+ * @example snakeCase('Hello World') // 'hello_world'
+ */
+export declare function snakeCase(str: string): string;
+/**
+ * kebab-case로 변환
+ * @example kebabCase('helloWorld') // 'hello-world'
+ * @example kebabCase('Hello World') // 'hello-world'
+ */
+export declare function kebabCase(str: string): string;
+/**
+ * CONSTANT_CASE로 변환
+ * @example constantCase('helloWorld') // 'HELLO_WORLD'
+ */
+export declare function constantCase(str: string): string;
+//# sourceMappingURL=case.d.ts.map

package/dist/string/case.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"case.d.ts","sourceRoot":"","sources":["../../src/string/case.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;GAGG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAG9C;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAGnD;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAI7C;AAED;;;GAGG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAE9C;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAO7C;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAO7C;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAEhD"}

package/dist/string/case.js

@@ -0,0 +1,71 @@
+/**
+ * String Case Conversion Utilities
+ */
+/**
+ * 첫 글자를 대문자로 변환
+ * @example capitalize('hello world') // 'Hello world'
+ */
+export function capitalize(str) {
+    if (!str)
+        return str;
+    return str.charAt(0).toUpperCase() + str.slice(1);
+}
+/**
+ * 모든 단어의 첫 글자를 대문자로 변환
+ * @example capitalizeWords('hello world') // 'Hello World'
+ */
+export function capitalizeWords(str) {
+    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) {
+    return str
+        .toLowerCase()
+        .replace(/[^a-zA-Z0-9]+(.)/g, (_, char) => char.toUpperCase());
+}
+/**
+ * PascalCase로 변환
+ * @example pascalCase('hello world') // 'HelloWorld'
+ */
+export function pascalCase(str) {
+    return capitalize(camelCase(str));
+}
+/**
+ * snake_case로 변환
+ * @example snakeCase('helloWorld') // 'hello_world'
+ * @example snakeCase('Hello World') // 'hello_world'
+ */
+export function snakeCase(str) {
+    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) {
+    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) {
+    return snakeCase(str).toUpperCase();
+}

package/dist/string/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * String Utilities
+ *
+ * This module provides utilities for string case conversion, manipulation, and validation.
+ */
+export * from './case';
+export * from './manipulation';
+export * from './validation';
+//# sourceMappingURL=index.d.ts.map

package/dist/string/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/string/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,cAAc,QAAQ,CAAC;AAGvB,cAAc,gBAAgB,CAAC;AAG/B,cAAc,cAAc,CAAC"}

package/dist/string/index.js

@@ -0,0 +1,11 @@
+/**
+ * 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/dist/string/manipulation.d.ts

@@ -0,0 +1,61 @@
+/**
+ * String Manipulation Utilities
+ */
+/**
+ * 문자열을 지정된 길이로 자르고 말줄임표 추가
+ * @example truncate('Hello World', 5) // 'Hello...'
+ */
+export declare function truncate(str: string, length: number, suffix?: string): string;
+/**
+ * 문자열 양쪽 공백 제거 및 연속된 공백을 하나로
+ * @example normalizeWhitespace('  hello   world  ') // 'hello world'
+ */
+export declare function normalizeWhitespace(str: string): string;
+/**
+ * URL 친화적인 슬러그 생성
+ * @example slugify('Hello World!') // 'hello-world'
+ * @example slugify('Test123 World') // 'test123-world'
+ */
+export declare function slugify(str: string): string;
+/**
+ * 랜덤 문자열 생성
+ * @param length - 생성할 문자열 길이
+ * @param charset - 사용할 문자 집합 ('alphanumeric', 'alpha', 'numeric', 'hex')
+ */
+export declare function randomString(length: number, charset?: 'alphanumeric' | 'alpha' | 'numeric' | 'hex'): string;
+/**
+ * 문자열 반복
+ * @example repeat('ab', 3) // 'ababab'
+ */
+export declare function repeat(str: string, count: number): string;
+/**
+ * 문자열 뒤집기
+ * @example reverse('hello') // 'olleh'
+ */
+export declare function reverse(str: string): string;
+/**
+ * 문자열에서 HTML 태그 제거
+ * @example stripHtml('<p>Hello <strong>World</strong></p>') // 'Hello World'
+ */
+export declare function stripHtml(str: string): string;
+/**
+ * 문자열을 특정 길이로 패딩
+ * @example padStart('5', 3, '0') // '005'
+ */
+export declare function padStart(str: string, length: number, fillString?: string): string;
+/**
+ * 문자열을 특정 길이로 패딩 (오른쪽)
+ * @example padEnd('5', 3, '0') // '500'
+ */
+export declare function padEnd(str: string, length: number, fillString?: string): string;
+/**
+ * 템플릿 문자열 치환
+ * @example template('Hello {name}!', { name: 'World' }) // 'Hello World!'
+ */
+export declare function template(str: string, values: Record<string, any>): string;
+/**
+ * 마스킹 (특정 위치의 문자를 *로 변경)
+ * @example mask('1234567890', 3, 7) // '123****890'
+ */
+export declare function mask(str: string, start: number, end?: number, maskChar?: string): string;
+//# sourceMappingURL=manipulation.d.ts.map

package/dist/string/manipulation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manipulation.d.ts","sourceRoot":"","sources":["../../src/string/manipulation.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;GAGG;AACH,wBAAgB,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAE,MAAc,GAAG,MAAM,CAGpF;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAEvD;AAED;;;;GAIG;AACH,wBAAgB,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAQ3C;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAC1B,MAAM,EAAE,MAAM,EACd,OAAO,GAAE,cAAc,GAAG,OAAO,GAAG,SAAS,GAAG,KAAsB,GACrE,MAAM,CAgBR;AAED;;;GAGG;AACH,wBAAgB,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAEzD;AAED;;;GAGG;AACH,wBAAgB,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAE3C;AAED;;;GAGG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAE7C;AAED;;;GAGG;AACH,wBAAgB,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,GAAE,MAAY,GAAG,MAAM,CAEtF;AAED;;;GAGG;AACH,wBAAgB,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,GAAE,MAAY,GAAG,MAAM,CAEpF;AAED;;;GAGG;AACH,wBAAgB,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,MAAM,CAIzE;AAED;;;GAGG;AACH,wBAAgB,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,EAAE,QAAQ,GAAE,MAAY,GAAG,MAAM,CAO7F"}

package/dist/string/manipulation.js

@@ -0,0 +1,106 @@
+/**
+ * String Manipulation Utilities
+ */
+/**
+ * 문자열을 지정된 길이로 자르고 말줄임표 추가
+ * @example truncate('Hello World', 5) // 'Hello...'
+ */
+export function truncate(str, length, suffix = '...') {
+    if (str.length <= length)
+        return str;
+    return str.slice(0, length) + suffix;
+}
+/**
+ * 문자열 양쪽 공백 제거 및 연속된 공백을 하나로
+ * @example normalizeWhitespace('  hello   world  ') // 'hello world'
+ */
+export function normalizeWhitespace(str) {
+    return str.trim().replace(/\s+/g, ' ');
+}
+/**
+ * URL 친화적인 슬러그 생성
+ * @example slugify('Hello World!') // 'hello-world'
+ * @example slugify('Test123 World') // 'test123-world'
+ */
+export function slugify(str) {
+    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, charset = 'alphanumeric') {
+    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, count) {
+    return str.repeat(count);
+}
+/**
+ * 문자열 뒤집기
+ * @example reverse('hello') // 'olleh'
+ */
+export function reverse(str) {
+    return str.split('').reverse().join('');
+}
+/**
+ * 문자열에서 HTML 태그 제거
+ * @example stripHtml('<p>Hello <strong>World</strong></p>') // 'Hello World'
+ */
+export function stripHtml(str) {
+    return str.replace(/<[^>]*>/g, '');
+}
+/**
+ * 문자열을 특정 길이로 패딩
+ * @example padStart('5', 3, '0') // '005'
+ */
+export function padStart(str, length, fillString = ' ') {
+    return str.padStart(length, fillString);
+}
+/**
+ * 문자열을 특정 길이로 패딩 (오른쪽)
+ * @example padEnd('5', 3, '0') // '500'
+ */
+export function padEnd(str, length, fillString = ' ') {
+    return str.padEnd(length, fillString);
+}
+/**
+ * 템플릿 문자열 치환
+ * @example template('Hello {name}!', { name: 'World' }) // 'Hello World!'
+ */
+export function template(str, values) {
+    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, start, end, maskChar = '*') {
+    const endPos = end ?? str.length;
+    return (str.slice(0, start) +
+        maskChar.repeat(endPos - start) +
+        str.slice(endPos));
+}

package/dist/string/validation.d.ts

@@ -0,0 +1,79 @@
+/**
+ * String Validation Utilities
+ */
+/**
+ * 빈 문자열 또는 공백만 있는지 확인
+ * @example isEmpty('') // true
+ * @example isEmpty('  ') // true
+ * @example isEmpty('hello') // false
+ */
+export declare function isEmpty(str: string): boolean;
+/**
+ * 문자열이 특정 문자로 시작하는지 확인
+ * @example startsWith('hello', 'he') // true
+ */
+export declare function startsWith(str: string, searchString: string): boolean;
+/**
+ * 문자열이 특정 문자로 끝나는지 확인
+ * @example endsWith('hello', 'lo') // true
+ */
+export declare function endsWith(str: string, searchString: string): boolean;
+/**
+ * 문자열에 특정 문자열이 포함되어 있는지 확인
+ * @example contains('hello world', 'world') // true
+ */
+export declare function contains(str: string, searchString: string): boolean;
+/**
+ * 알파벳만 포함하는지 확인
+ * @example isAlpha('hello') // true
+ * @example isAlpha('hello123') // false
+ */
+export declare function isAlpha(str: string): boolean;
+/**
+ * 숫자만 포함하는지 확인
+ * @example isNumeric('123') // true
+ * @example isNumeric('123.45') // false
+ */
+export declare function isNumeric(str: string): boolean;
+/**
+ * 알파벳과 숫자만 포함하는지 확인
+ * @example isAlphanumeric('hello123') // true
+ * @example isAlphanumeric('hello_123') // false
+ */
+export declare function isAlphanumeric(str: string): boolean;
+/**
+ * 소문자만 포함하는지 확인
+ * @example isLowerCase('hello') // true
+ * @example isLowerCase('Hello') // false
+ */
+export declare function isLowerCase(str: string): boolean;
+/**
+ * 대문자만 포함하는지 확인
+ * @example isUpperCase('HELLO') // true
+ * @example isUpperCase('Hello') // false
+ */
+export declare function isUpperCase(str: string): boolean;
+/**
+ * JSON 형식인지 확인
+ * @example isJSON('{"name":"John"}') // true
+ * @example isJSON('not json') // false
+ */
+export declare function isJSON(str: string): boolean;
+/**
+ * 16진수 색상 코드인지 확인
+ * @example isHexColor('#fff') // true
+ * @example isHexColor('#ffffff') // true
+ * @example isHexColor('fff') // false
+ */
+export declare function isHexColor(str: string): boolean;
+/**
+ * UUID 형식인지 확인
+ * @example isUUID('123e4567-e89b-12d3-a456-426614174000') // true
+ */
+export declare function isUUID(str: string): boolean;
+/**
+ * Base64 인코딩된 문자열인지 확인
+ * @example isBase64('SGVsbG8gV29ybGQ=') // true
+ */
+export declare function isBase64(str: string): boolean;
+//# sourceMappingURL=validation.d.ts.map

package/dist/string/validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../src/string/validation.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;;;GAKG;AACH,wBAAgB,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAE5C;AAED;;;GAGG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,OAAO,CAErE;AAED;;;GAGG;AACH,wBAAgB,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,OAAO,CAEnE;AAED;;;GAGG;AACH,wBAAgB,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,OAAO,CAEnE;AAED;;;;GAIG;AACH,wBAAgB,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAE5C;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAE9C;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAEnD;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAEhD;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAEhD;AAED;;;;GAIG;AACH,wBAAgB,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAO3C;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAE/C;AAED;;;GAGG;AACH,wBAAgB,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAE3C;AAED;;;GAGG;AACH,wBAAgB,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAM7C"}