korrect-js 1.0.2

package/README.md

@@ -0,0 +1,89 @@
+# korrect-js
+
+[![npm version](https://img.shields.io/npm/v/korrect-js.svg)](https://www.npmjs.com/package/korrect-js)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+**korrect-js**는 한국어 텍스트 처리와 맞춤법 검사를 간편하게 수행할 수 있는 자바스크립트 라이브러리입니다. 초성 추출, 조사 선택, 영타/한타 변환 등 한국어 서비스 개발에 꼭 필요한 유틸리티들을 제공합니다.
+
+## 주요 기능
+
+- **맞춤법 검사**: 문장의 맞춤법을 교정하고, 에러 위치와 교정 제안을 포함한 상세 데이터를 반환합니다.
+- **초성 추출**: 한글 단어에서 초성(ㄱㄴㄷ...)만 깔끔하게 추출합니다.
+- **조사 자동 선택**: 단어의 종성(받침) 여부에 따라 적합한 조사(은/는, 이/가, 을/를)를 자동으로 선택합니다.
+- **영타/한타 변환**: 키보드 입력 실수를 교정하거나 한글을 로마자로 변환하는 기능을 제공합니다.
+
+## 설치
+
+```bash
+npm install korrect-js
+```
+
+## 사용법
+
+```javascript
+const korrect = require('korrect-js');
+
+// 1. 맞춤법 검사 (Async)
+async function checkSpell() {
+    const result = await korrect.check("바나나가 잇다");
+    console.log(result.corrected); // "바나나가 있다"
+}
+
+// 2. 초성 추출
+const chosung = korrect.chosung("가느다란 물방울"); 
+console.log(chosung); // "ㄱㄴㄷㄹ ㅁㅂㅇ"
+
+// 3. 조사 자동 선택
+const word = "사과";
+const sentence = `${word}${korrect.pickJosa(word, ["은", "는"])} 맛있다.`;
+console.log(sentence); // "사과는 맛있다."
+
+// 4. 영타/한타 변환
+console.log(korrect.toKo("dkssud")); // "안녕"
+console.log(korrect.toEn("안녕"));   // "dkssud"
+console.log(korrect.toRoman("나비")); // "nabi"
+```
+
+## API 상세
+
+### `check(text)`
+네이버 맞춤법 검사기 API를 사용하여 문장을 검사합니다.
+- **Parameters**: `text` (string)
+- **Returns**: `Promise<object>`
+  - `original`: 원본 문장
+  - `corrected`: 교정된 문장
+  - `errors`: 에러 배열 (wrong, right, start, end)
+  - `errata_count`: 에러 개수
+
+### `chosung(word)`
+- **Parameters**: `word` (string)
+- **Returns**: `string` (추출된 초성)
+
+### `pickJosa(word, josa)`
+- **Parameters**: 
+  - `word`: 대상 단어
+  - `josa`: `["은", "는"]` 형태의 조사 쌍
+- **Returns**: `string` (선택된 조사)
+
+### `toEn(word)` / `toKo(word)` / `toRoman(word)`
+- 한글↔영어 키보드 입력 변환 및 로마자 표기법 변환을 수행합니다.
+
+## 프로젝트 구조
+
+```text
+korrect/
+├── lib/          # 핵심 로직 (check, chosung, pickJosa, trans)
+├── tests/        # 테스트 스크립트
+├── index.js      # 엔트리 포인트
+└── package.json
+```
+
+## 링크
+
+- **개발자**: [https://jeeks.my](https://jeeks.my)
+- **GitHub**: [https://github.com/jikwxng/korrect](https://github.com/jikwxng/korrect)
+- **NPM**: [https://www.npmjs.com/package/korrect-js](https://www.npmjs.com/package/korrect-js)
+
+## 라이선스
+
+이 프로젝트는 [MIT License](LICENSE)를 따릅니다.

package/index.js

@@ -0,0 +1,13 @@
+const chosung = require('./lib/chosung');
+const pickJosa = require('./lib/pickJosa');
+const { toEn, toKo, toRoman } = require('./lib/trans');
+const check = require('./lib/check');
+
+module.exports = {
+    chosung,
+    pickJosa,
+    toEn,
+    toKo,
+    toRoman,
+    check
+};

package/lib/check.js

@@ -0,0 +1,65 @@
+const axios = require('axios');
+
+/**
+ * 문장의 맞춤법을 검사하고 교정된 결과를 반환합니다.
+ * @param {string} text - 맞춤법을 검사할 문장
+ * @returns {Promise<object|null>} 교정된 결과 객체
+ * @example
+ * const result = await korrect.check("바나나가 잇다");
+ * // { original: "바나나가 잇다", corrected: "바나나가 있다", errors: [...], errata_count: 1 }
+ */
+async function check(text) {
+    if (typeof text !== 'string' || text.length === 0) return null;
+
+    try {
+        const encodedText = encodeURIComponent(text);
+        const url = `https://ts-proxy.naver.com/ocontent/util/SpellerProxy?passportKey=12e3a39878a34a48ba1dfd7203522054aa417829&q=${encodedText}&where=nexearch&color_blindness=0`;
+
+        const response = await axios.get(url);
+        const result = response.data.message.result;
+
+        const stripTags = (str) => str.replace(/<[^>]*>?/gm, '');
+        const originalText = stripTags(result.origin_html);
+        const correctedText = stripTags(result.html);
+
+        const originalWords = originalText.split(/\s+/);
+        const correctedWords = correctedText.split(/\s+/);
+        
+        const errors = [];
+        let currentOffset = 0;
+
+        originalWords.forEach((word, index) => {
+            const correctedWord = correctedWords[index];
+            
+            if (word !== correctedWord) {
+                errors.push({
+                    wrong: word,
+                    right: correctedWord,
+                    start: currentOffset,
+                    end: currentOffset + word.length
+                });
+            }
+
+            const nextSpaceIndex = originalText.indexOf(' ', currentOffset + word.length);
+            if (nextSpaceIndex !== -1) {
+                currentOffset = nextSpaceIndex + 1;
+            } else {
+                currentOffset += word.length + 1;
+            }
+        });
+
+        return {
+            original: originalText,
+            corrected: correctedText,
+            errors: errors,
+            errata_count: result.errata_count
+        };
+
+    } catch (error) {
+        console.error("맞춤법 검사 오류:", error.message);
+        return null;
+    }
+}
+
+module.exports = check;
+

package/lib/chosung.js

@@ -0,0 +1,22 @@
+/**
+ * 단어의 초성을 반환합니다.
+ * @param {string} word 
+ * @example korrect.chosung("가느다란 물방울") // "ㄱㄴㄷㄹ ㅁㅂㅇ"
+ */
+function chosung(word) {
+    if (typeof word !== 'string' || word.length === 0) throw new Error("Invalid input: 초성으로 변환할 단어를 입력해주세요.");
+    
+    let result = "";
+    for (let i = 0; i < word.length; i++) {
+        const firstCode = word.charCodeAt(i);
+        if (firstCode >= 0xAC00 && firstCode <= 0xD7A3) {
+            const chosungCode = Math.floor((firstCode - 0xAC00) / 588) + 0x1100;
+            result += String.fromCharCode(chosungCode);
+        } else {
+            result += word[i];
+        }
+    }
+    return result;
+}
+
+module.exports = chosung;

package/lib/pickJosa.js

@@ -0,0 +1,24 @@
+/**
+ * 단어에 따라 조사를 붙입니다.
+ * @param {string} word - 조사가 붙을 단어
+ * @param {string[]} josa - 단어 뒤에 붙을 조사
+ * @returns {string}
+ * @example
+ * korrect.pickJosa("사과", ["을", "를"]) // "사과를"
+ * korrect.pickJosa("길동", ["이", "가"]) // "길동이"
+ */
+function pickJosa(word, josa) {
+    if (typeof word !== 'string' || word.length === 0) return word;
+    if (!Array.isArray(josa) || josa.length !== 2) return word;
+
+    const lastChar = word[word.length - 1];
+    const code = lastChar.charCodeAt(0);
+    if (code < 0xAC00 || code > 0xD7A3) {
+        return word + josa[0];
+    }
+    const hasBatchim = (code - 0xAC00) % 28 > 0;
+
+    return word + (hasBatchim ? josa[0] : josa[1]);
+}
+
+module.exports = pickJosa;

package/lib/trans.js

@@ -0,0 +1,196 @@
+/**
+ * 한타를 영타로 변환합니다.
+ * @param {string} word - 변환할 한글 단어
+ * @example toEn("안녕") // "dkssud"
+ */
+function toEn(word) {
+    if (typeof word !== 'string' || word.length === 0) return word;
+
+    const CHOSUNG = [
+        'r', 'R', 's', 'e', 'E', 'f', 'a', 'q', 'Q', 't', 'T', 'd', 'w', 'W', 'c', 'v', 'x', 'z', 'g'
+    ];
+    const JUNGSUNG = [
+        'k', 'o', 'i', 'O', 'j', 'p', 'u', 'P', 'h', 'hk', 'ho', 'hl', 'y', 'n', 'nj', 'np', 'nl', 'b', 'm', 'ml', 'l'
+    ];
+    const JONGSUNG = [
+        '', 'r', 'R', 'rt', 's', 'sw', 'sg', 'e', 'f', 'fr', 'fa', 'fq', 'ft', 'fx', 'fz', 'fg', 'a', 'q', 'qt', 't', 'T', 'd', 'w', 'c', 'v', 'x', 'z', 'g'
+    ];
+
+    const JAMO_MAP = {
+        'ㄱ': 'r', 'ㄲ': 'R', 'ㄴ': 's', 'ㄷ': 'e', 'ㄸ': 'E', 'ㄹ': 'f', 'ㅁ': 'a', 'ㅂ': 'q', 'ㅃ': 'Q', 'ㅅ': 't', 'ㅆ': 'T', 'ㅇ': 'd', 'ㅈ': 'w', 'ㅉ': 'W', 'ㅊ': 'c', 'ㅋ': 'v', 'ㅌ': 'x', 'ㅍ': 'z', 'ㅎ': 'g',
+        'ㅏ': 'k', 'ㅐ': 'o', 'ㅑ': 'i', 'ㅒ': 'O', 'ㅓ': 'j', 'ㅔ': 'p', 'ㅕ': 'u', 'ㅖ': 'P', 'ㅗ': 'h', 'ㅘ': 'hk', 'ㅙ': 'ho', 'ㅚ': 'hl', 'ㅛ': 'y', 'ㅜ': 'n', 'ㅝ': 'nj', 'ㅞ': 'np', 'ㅟ': 'nl', 'ㅠ': 'b', 'ㅡ': 'm', 'ㅢ': 'ml', 'ㅣ': 'l',
+        'ㄳ': 'rt', 'ㄵ': 'sw', 'ㄶ': 'sg', 'ㄺ': 'fr', 'ㄻ': 'fa', 'ㄼ': 'fq', 'ㄽ': 'ft', 'ㄾ': 'fx', 'ㄿ': 'fz', 'ㅀ': 'fg', 'ㅄ': 'qt'
+    };
+
+    let result = "";
+    for (let i = 0; i < word.length; i++) {
+        const code = word.charCodeAt(i);
+        
+        if (code >= 0xAC00 && code <= 0xD7A3) { // 완성형 한글
+            const base = code - 0xAC00;
+            const cho = Math.floor(base / 588);
+            const jung = Math.floor((base % 588) / 28);
+            const jong = base % 28;
+            result += CHOSUNG[cho] + JUNGSUNG[jung] + JONGSUNG[jong];
+        } else if (JAMO_MAP[word[i]]) { // 개별 자모
+            result += JAMO_MAP[word[i]];
+        } else { // 그 외
+            result += word[i];
+        }
+    }
+    return result;
+}
+
+/**
+ * 영타를 한타로 변환합니다.
+
+ * @param {string} englishWord - 변환할 영문 단어
+ * @example toKo("dkssud") // "안녕"
+ */
+function toKo(englishWord) {
+    if (typeof englishWord !== 'string' || englishWord.length === 0) return englishWord;
+
+    const enToKoMap = {
+        'r': 'ㄱ', 'R': 'ㄲ', 's': 'ㄴ', 'e': 'ㄷ', 'E': 'ㄸ', 'f': 'ㄹ', 'a': 'ㅁ', 'q': 'ㅂ', 'Q': 'ㅃ', 't': 'ㅅ', 'T': 'ㅆ', 'd': 'ㅇ', 'w': 'ㅈ', 'W': 'ㅉ', 'c': 'ㅊ', 'v': 'ㅋ', 'x': 'ㅌ', 'z': 'ㅍ', 'g': 'ㅎ',
+        'k': 'ㅏ', 'o': 'ㅐ', 'i': 'ㅑ', 'O': 'ㅒ', 'j': 'ㅓ', 'p': 'ㅔ', 'u': 'ㅕ', 'P': 'ㅖ', 'h': 'ㅗ', 'y': 'ㅛ', 'n': 'ㅜ', 'b': 'ㅠ', 'm': 'ㅡ', 'l': 'ㅣ'
+    };
+
+    const CHOSUNG = ['ㄱ', 'ㄲ', 'ㄴ', 'ㄷ', 'ㄸ', 'ㄹ', 'ㅁ', 'ㅂ', 'ㅃ', 'ㅅ', 'ㅆ', 'ㅇ', 'ㅈ', 'ㅉ', 'ㅊ', 'ㅋ', 'ㅌ', 'ㅍ', 'ㅎ'];
+    const JUNGSUNG = ['ㅏ', 'ㅐ', 'ㅑ', 'ㅒ', 'ㅓ', 'ㅔ', 'ㅕ', 'ㅖ', 'ㅗ', 'ㅘ', 'ㅙ', 'ㅚ', 'ㅛ', 'ㅜ', 'ㅝ', 'ㅞ', 'ㅟ', 'ㅠ', 'ㅡ', 'ㅢ', 'ㅣ'];
+    const JONGSUNG = ['', 'ㄱ', 'ㄲ', 'ㄳ', 'ㄴ', 'ㄵ', 'ㄶ', 'ㄷ', 'ㄹ', 'ㄺ', 'ㄻ', 'ㄼ', 'ㄽ', 'ㄾ', 'ㄿ', 'ㅀ', 'ㅁ', 'ㅂ', 'ㅄ', 'ㅅ', 'ㅆ', 'ㅇ', 'ㅈ', 'ㅊ', 'ㅋ', 'ㅌ', 'ㅍ', 'ㅎ'];
+
+    const jungComplex = { 'ㅗㅏ': 'ㅘ', 'ㅗㅐ': 'ㅙ', 'ㅗㅣ': 'ㅚ', 'ㅜㅓ': 'ㅝ', 'ㅜㅔ': 'ㅞ', 'ㅜㅣ': 'ㅟ', 'ㅡㅣ': 'ㅢ' };
+    const jongComplex = { 'ㄱㅅ': 'ㄳ', 'ㄴㅈ': 'ㄵ', 'ㄴㅎ': 'ㄶ', 'ㄹㄱ': 'ㄺ', 'ㄹㅁ': 'ㄻ', 'ㄹㅂ': 'ㄼ', 'ㄹㅅ': 'ㄽ', 'ㄹㅌ': 'ㄾ', 'ㄹㅍ': 'ㄿ', 'ㄹㅎ': 'ㅀ', 'ㅂㅅ': 'ㅄ' };
+
+    let result = '';
+    let cho = -1, jung = -1, jong = -1;
+    let lastJong = -1;
+
+    const combine = () => {
+        if (cho !== -1 && jung !== -1) {
+            result += String.fromCharCode(0xAC00 + (cho * 21 + jung) * 28 + (jong !== -1 ? jong : 0));
+        } else if (cho !== -1) {
+            result += CHOSUNG[cho];
+        } else if (jung !== -1) {
+            result += JUNGSUNG[jung];
+        }
+        cho = jung = jong = -1;
+        lastJong = -1;
+    };
+
+    for (let i = 0; i < englishWord.length; i++) {
+        const key = englishWord[i];
+        const jamo = enToKoMap[key];
+
+        if (!jamo) {
+            combine();
+            result += key;
+            continue;
+        }
+
+        const isVowel = 'ㅏㅐㅑㅒㅓㅔㅕㅖㅗㅛㅜㅠㅡㅣ'.includes(jamo);
+
+        if (isVowel) {
+            if (cho !== -1 && jung === -1) {
+                jung = JUNGSUNG.indexOf(jamo);
+            } else if (cho !== -1 && jung !== -1 && jong === -1) {
+                const complex = jungComplex[JUNGSUNG[jung] + jamo];
+                if (complex) {
+                    jung = JUNGSUNG.indexOf(complex);
+                } else {
+                    combine();
+                    jung = JUNGSUNG.indexOf(jamo);
+                }
+            } else if (cho !== -1 && jung !== -1 && jong !== -1) {
+                if (lastJong !== -1) {
+                    const complexChar = JONGSUNG[jong];
+                    const splitJamo = Object.keys(jongComplex).find(k => jongComplex[k] === complexChar);
+                    jong = JONGSUNG.indexOf(splitJamo[0]);
+                    combine();
+                    cho = CHOSUNG.indexOf(splitJamo[1]);
+                    jung = JUNGSUNG.indexOf(jamo);
+                } else {
+                    const prevJongChar = JONGSUNG[jong];
+                    jong = 0;
+                    combine();
+                    cho = CHOSUNG.indexOf(prevJongChar);
+                    jung = JUNGSUNG.indexOf(jamo);
+                }
+            } else {
+                if (jung !== -1) {
+                    const complex = jungComplex[JUNGSUNG[jung] + jamo];
+                    if (complex) jung = JUNGSUNG.indexOf(complex);
+                    else { combine(); jung = JUNGSUNG.indexOf(jamo); }
+                } else {
+                    jung = JUNGSUNG.indexOf(jamo);
+                }
+            }
+        } else {
+            if (cho === -1) {
+                cho = CHOSUNG.indexOf(jamo);
+            } else if (jung === -1) {
+                combine();
+                cho = CHOSUNG.indexOf(jamo);
+            } else if (jong === -1) {
+                const jIdx = JONGSUNG.indexOf(jamo);
+                if (jIdx !== -1) {
+                    jong = jIdx;
+                } else {
+                    combine();
+                    cho = CHOSUNG.indexOf(jamo);
+                }
+            } else if (lastJong === -1) {
+                const complex = jongComplex[JONGSUNG[jong] + jamo];
+                if (complex) {
+                    lastJong = jong;
+                    jong = JONGSUNG.indexOf(complex);
+                } else {
+                    combine();
+                    cho = CHOSUNG.indexOf(jamo);
+                }
+            } else {
+                combine();
+                cho = CHOSUNG.indexOf(jamo);
+            }
+        }
+    }
+    combine();
+    return result;
+}
+
+/**
+
+ * 한글을 로마자로 변환합니다. `(문화관광부 고시 제2000-8호 규격)`
+ * @param {string} word - 변환할 한글 단어
+ * @example toRoman("나비야") // "nabiya"
+ */
+function toRoman(word) {
+    if (typeof word !== 'string' || word.length === 0) return word;
+
+    const CHOSUNG = ['g', 'kk', 'n', 'd', 'tt', 'r', 'm', 'b', 'pp', 's', 'ss', '', 'j', 'jj', 'ch', 'k', 't', 'p', 'h'];
+    const JUNGSUNG = ['a', 'ae', 'ya', 'yae', 'eo', 'e', 'yeo', 'ye', 'o', 'wa', 'wae', 'oe', 'yo', 'u', 'wo', 'we', 'wi', 'yu', 'eu', 'ui', 'i'];
+    const JONGSUNG = ['', 'k', 'k', 'k', 'n', 'n', 'n', 't', 'l', 'k', 'm', 'l', 'l', 't', 'p', 'l', 'm', 'p', 'p', 't', 't', 'ng', 't', 't', 'k', 't', 'p', 't'];
+
+    let result = "";
+    for (let i = 0; i < word.length; i++) {
+        const code = word.charCodeAt(i);
+        
+        if (code >= 0xAC00 && code <= 0xD7A3) { // 완성형 한글
+            const base = code - 0xAC00;
+            const cho = Math.floor(base / 588);
+            const jung = Math.floor((base % 588) / 28);
+            const jong = base % 28;
+            
+            result += CHOSUNG[cho] + JUNGSUNG[jung] + JONGSUNG[jong];
+        } else {
+            // 개별 자모(0x3130~0x318F, 0x1100~0x11FF 등)는 제외하고 나머지만 추가
+            const isJamo = (code >= 0x3130 && code <= 0x318F) || (code >= 0x1100 && code <= 0x11FF);
+            if (!isJamo) {
+                result += word[i];
+            }
+        }
+    }
+    return result;
+}
+
+module.exports = { toEn, toKo, toRoman };

package/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "korrect-js",
+  "version": "1.0.2",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "test": "node tests/test.js"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "axios": "^1.16.0"
+  }
+}