goodchuck-utils 1.1.0 → 1.3.0

package/dist/hooks/useSessionStorage.js

@@ -0,0 +1,85 @@
+import { useState, useEffect, useCallback } from 'react';
+/**
+ * sessionStorage와 동기화되는 state hook
+ *
+ * @param key - sessionStorage 키
+ * @param initialValue - 초기값
+ * @returns [storedValue, setValue, removeValue]
+ *
+ * @example
+ * const [token, setToken, removeToken] = useSessionStorage('auth-token', '');
+ *
+ * // 값 설정
+ * setToken('abc123');
+ *
+ * // 값 제거
+ * removeToken();
+ */
+export function useSessionStorage(key, initialValue) {
+    // SSR 안전성 체크
+    const isBrowser = typeof window !== 'undefined';
+    // 초기값을 sessionStorage에서 가져오기
+    const readValue = useCallback(() => {
+        if (!isBrowser) {
+            return initialValue;
+        }
+        try {
+            const item = window.sessionStorage.getItem(key);
+            return item ? JSON.parse(item) : initialValue;
+        }
+        catch (error) {
+            console.warn(`Error reading sessionStorage key "${key}":`, error);
+            return initialValue;
+        }
+    }, [initialValue, key, isBrowser]);
+    const [storedValue, setStoredValue] = useState(readValue);
+    // 값 설정 함수
+    const setValue = useCallback((value) => {
+        if (!isBrowser) {
+            console.warn(`Tried setting sessionStorage key "${key}" even though environment is not a client`);
+            return;
+        }
+        try {
+            // useState와 동일하게 함수형 업데이트 지원
+            const newValue = value instanceof Function ? value(storedValue) : value;
+            // sessionStorage에 저장
+            window.sessionStorage.setItem(key, JSON.stringify(newValue));
+            // state 업데이트
+            setStoredValue(newValue);
+            // storage event 발생
+            window.dispatchEvent(new Event('session-storage'));
+        }
+        catch (error) {
+            console.warn(`Error setting sessionStorage key "${key}":`, error);
+        }
+    }, [key, storedValue, isBrowser]);
+    // 값 제거 함수
+    const removeValue = useCallback(() => {
+        if (!isBrowser) {
+            return;
+        }
+        try {
+            window.sessionStorage.removeItem(key);
+            setStoredValue(initialValue);
+            window.dispatchEvent(new Event('session-storage'));
+        }
+        catch (error) {
+            console.warn(`Error removing sessionStorage key "${key}":`, error);
+        }
+    }, [key, initialValue, isBrowser]);
+    // 같은 페이지 내의 변경사항 감지
+    useEffect(() => {
+        if (!isBrowser) {
+            return;
+        }
+        const handleStorageChange = () => {
+            setStoredValue(readValue());
+        };
+        // 같은 페이지 내의 변경사항
+        window.addEventListener('session-storage', handleStorageChange);
+        return () => {
+            window.removeEventListener('session-storage', handleStorageChange);
+        };
+    }, [key, readValue, isBrowser]);
+    return [storedValue, setValue, removeValue];
+}

package/dist/index.d.ts

@@ -1,5 +1,4 @@
-declare function add(a: number, b: number): number;
-declare function subtract(a: number, b: number): number;
-declare function multiply(a: number, b: number): number;
-declare function divide(a: number, b: number): number;
-export { add, subtract, multiply, divide };
+export * from './date';
+export * from './form';
+export * from './string';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,cAAc,QAAQ,CAAC;AAGvB,cAAc,QAAQ,CAAC;AAGvB,cAAc,UAAU,CAAC"}

package/dist/index.js

@@ -1,18 +1,13 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.add = add;
-exports.subtract = subtract;
-exports.multiply = multiply;
-exports.divide = divide;
-function add(a, b) {
-    return a + b;
-}
-function subtract(a, b) {
-    return a - b;
-}
-function multiply(a, b) {
-    return a * b;
-}
-function divide(a, b) {
-    return a / b;
-}
+// Date utilities
+export * from './date';
+// Form utilities
+export * from './form';
+// String utilities
+export * from './string';
+// React Hooks (import separately: 'goodchuck-utils/hooks')
+// Note: Hooks are not exported from main entry to avoid React dependency for non-React users
+// export * from './hooks';
+// Array utilities (placeholder for future)
+// export * from './array';
+// Object utilities (placeholder for future)
+// export * from './object';

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

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

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

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

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

@@ -0,0 +1,61 @@
+import { describe, it, expect } from 'vitest';
+import { capitalize, capitalizeWords, camelCase, pascalCase, snakeCase, kebabCase, constantCase, } from '../case';
+describe('String Case Conversion', () => {
+    describe('capitalize', () => {
+        it('should capitalize first letter', () => {
+            expect(capitalize('hello')).toBe('Hello');
+            expect(capitalize('hello world')).toBe('Hello world');
+            expect(capitalize('HELLO')).toBe('HELLO');
+        });
+        it('should handle empty string', () => {
+            expect(capitalize('')).toBe('');
+        });
+    });
+    describe('capitalizeWords', () => {
+        it('should capitalize each word', () => {
+            expect(capitalizeWords('hello world')).toBe('Hello World');
+            expect(capitalizeWords('the quick brown fox')).toBe('The Quick Brown Fox');
+        });
+    });
+    describe('camelCase', () => {
+        it('should convert to camelCase', () => {
+            expect(camelCase('hello world')).toBe('helloWorld');
+            expect(camelCase('hello-world')).toBe('helloWorld');
+            expect(camelCase('hello_world')).toBe('helloWorld');
+            expect(camelCase('Hello World')).toBe('helloWorld');
+        });
+        it('should handle already camelCase strings', () => {
+            expect(camelCase('helloWorld')).toBe('helloworld');
+        });
+    });
+    describe('pascalCase', () => {
+        it('should convert to PascalCase', () => {
+            expect(pascalCase('hello world')).toBe('HelloWorld');
+            expect(pascalCase('hello-world')).toBe('HelloWorld');
+            expect(pascalCase('hello_world')).toBe('HelloWorld');
+        });
+    });
+    describe('snakeCase', () => {
+        it('should convert to snake_case', () => {
+            expect(snakeCase('helloWorld')).toBe('hello_world');
+            expect(snakeCase('Hello World')).toBe('hello_world');
+            expect(snakeCase('hello-world')).toBe('hello_world');
+            expect(snakeCase('HelloWorld')).toBe('hello_world');
+        });
+    });
+    describe('kebabCase', () => {
+        it('should convert to kebab-case', () => {
+            expect(kebabCase('helloWorld')).toBe('hello-world');
+            expect(kebabCase('Hello World')).toBe('hello-world');
+            expect(kebabCase('hello_world')).toBe('hello-world');
+            expect(kebabCase('HelloWorld')).toBe('hello-world');
+        });
+    });
+    describe('constantCase', () => {
+        it('should convert to CONSTANT_CASE', () => {
+            expect(constantCase('helloWorld')).toBe('HELLO_WORLD');
+            expect(constantCase('Hello World')).toBe('HELLO_WORLD');
+            expect(constantCase('hello-world')).toBe('HELLO_WORLD');
+        });
+    });
+});

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

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

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

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

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"}