geez-input 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Geez Input Library Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,208 @@
+# Geez Library
+
+A type-safe React library for Geez (Ethiopic) script input with phonetic keyboard support. Write Amharic, Tigrinya, and other Ethiopic languages using Latin characters that automatically transform to Geez script.
+
+## Features
+
+- **Type-Safe**: Built with TypeScript for full type safety with comprehensive JSDoc documentation
+- **Phonetic Keyboard**: Intuitive Latin-to-Geez transformation following standard conventions
+- **Customizable Components**: Pre-styled input and textarea components with toggle support
+- **React Hook**: `useGeez` hook for custom implementations
+- **Tree-Shakeable**: Optimized bundle size with CSS code splitting
+- **Form Library Support**: Works with React Hook Form, Formik, and other form libraries
+- **Controlled & Uncontrolled**: Full support for both component patterns
+
+## Installation
+
+```bash
+npm install geez-input
+```
+
+## Quick Start
+
+```tsx
+import { GeezInput, GeezTextArea } from 'geez-input'
+
+function App() {
+  return (
+    <div>
+      <GeezInput placeholder="Type in Geez..." />
+      <GeezTextArea placeholder="Write longer text..." />
+    </div>
+  )
+}
+```
+
+## Components
+
+### GeezInput
+
+A styled input component with built-in Geez phonetic keyboard support.
+
+```tsx
+import { GeezInput } from 'geez-input'
+import { useState } from 'react'
+
+function MyForm() {
+  const [name, setName] = useState('')
+
+  return (
+    <GeezInput
+      value={name}
+      onChange={(e) => setName(e.target.value)}
+      placeholder="Enter your name"
+    />
+  )
+}
+```
+
+### GeezTextArea
+
+A styled textarea component for longer text input.
+
+```tsx
+import { GeezTextArea } from 'geez-input'
+
+function MyForm() {
+  return (
+    <GeezTextArea
+      placeholder="Write your story..."
+      rows={5}
+    />
+  )
+}
+```
+
+## Hook API
+
+### useGeez
+
+For custom implementations, use the `useGeez` hook:
+
+```tsx
+import { useGeez } from 'geez-input'
+
+function CustomInput() {
+  const { onKeyDown } = useGeez({
+    enabled: true,
+    onTransform: (result) => {
+      console.log('Transformed:', result)
+    }
+  })
+
+  return <input onKeyDown={onKeyDown} />
+}
+```
+
+## Phonetic Guide
+
+The library uses intuitive phonetic mappings:
+
+### Consonants
+- `h` → ህ
+- `l` → ል
+- `m` → ም
+- `sh` → ሽ
+- `ch` → ች
+
+### Syllables
+Type a consonant followed by a vowel:
+- `ha` → ሀ
+- `lu` → ሉ
+- `mi` → ሚ
+- `sha` → ሻ
+
+### Double Vowels
+Type the same vowel twice for alternate forms:
+- `haa` → ሃ
+- `lee` → ሌ
+
+### Punctuation
+- `:` → ፡ (word separator)
+- `::` → ። (sentence ending)
+- `,` → ፣
+
+## Examples
+
+Type phonetically to get Geez text:
+
+- `selam` → ስላም (hello)
+- `ethiopia` → ኢትዮጵያ (Ethiopia)
+- `tena yistilign` → ጤና ይስጥልኝ (greetings)
+
+## API Reference
+
+### Components
+
+#### GeezInput
+
+Props:
+- `defaultGeez?: boolean` - Enable Geez mode by default (default: `true`)
+- `className?: string` - Additional CSS classes
+- `...InputHTMLAttributes` - All standard HTML input attributes
+
+#### GeezTextArea
+
+Props:
+- `defaultGeez?: boolean` - Enable Geez mode by default (default: `true`)
+- `className?: string` - Additional CSS classes
+- `...TextareaHTMLAttributes` - All standard HTML textarea attributes
+
+### Hooks
+
+#### useGeez(options)
+
+Options:
+- `enabled?: boolean` - Enable/disable transformation (default: `true`)
+- `onTransform?: (result: EngineResult) => void` - Callback after each transformation
+
+Returns:
+- `onKeyDown: KeyboardEventHandler` - Event handler for keyboard events
+
+### Engine
+
+#### GeezEngine.transform(textBefore, textAfter, key)
+
+Core transformation method:
+- `textBefore: string` - Text before cursor
+- `textAfter: string` - Text after cursor
+- `key: string` - Key pressed
+- Returns: `EngineResult`
+
+## TypeScript Support
+
+The library is written in TypeScript and provides comprehensive type definitions:
+
+```tsx
+import type {
+  GeezOptions,
+  EngineResult,
+  PhoneticMap,
+  SyllableMap
+} from 'geez-input'
+```
+
+## Browser Support
+
+- Modern browsers (Chrome, Firefox, Safari, Edge)
+- React 18 or 19
+- TypeScript 5+ (optional)
+
+## Contributing
+
+Contributions are welcome! Please see [CONTRIBUTING.md](CONTRIBUTING.md) for details.
+
+## License
+
+MIT License - see [LICENSE](LICENSE) for details.
+
+## Links
+
+- [GitHub Repository](https://github.com/yourusername/geez-library)
+- [NPM Package](https://www.npmjs.com/package/geez-input)
+- [Documentation Site](https://geez-library.vercel.app)
+- [Issue Tracker](https://github.com/yourusername/geez-library/issues)
+
+## Credits
+
+Built with TypeScript, React, and Vite.

package/dist/components/geez-input.d.ts

@@ -0,0 +1,57 @@
+import { default as React } from 'react';
+/**
+ * Props for the GeezInput component
+ * Extends all standard HTML input attributes
+ */
+export interface GeezInputProps extends React.InputHTMLAttributes<HTMLInputElement> {
+    /**
+     * Whether Geez input mode is enabled by default
+     * @default true
+     */
+    defaultGeez?: boolean;
+    /**
+     * Additional CSS classes to apply to the input wrapper
+     */
+    className?: string;
+}
+/**
+ * Styled input component with built-in Geez phonetic keyboard support
+ *
+ * Features:
+ * - Toggle button to switch between Geez and English input modes
+ * - Phonetic transformation (type 'hello' → 'ሀልሎ')
+ * - Full support for controlled and uncontrolled component patterns
+ * - Forward ref support for form libraries
+ * - Styled with a classic paper and ink aesthetic
+ *
+ * @example
+ * \`\`\`tsx
+ * // Basic usage
+ * <GeezInput placeholder="Type in Geez..." />
+ * \`\`\`
+ *
+ * @example
+ * \`\`\`tsx
+ * // Controlled component
+ * function MyForm() {
+ *   const [name, setName] = useState('')
+ *   return (
+ *     <GeezInput
+ *       value={name}
+ *       onChange={(e) => setName(e.target.value)}
+ *       placeholder="Enter your name"
+ *     />
+ *   )
+ * }
+ * \`\`\`
+ *
+ * @example
+ * \`\`\`tsx
+ * // With form library (React Hook Form)
+ * function MyForm() {
+ *   const { register } = useForm()
+ *   return <GeezInput {...register('name')} />
+ * }
+ * \`\`\`
+ */
+export declare const GeezInput: React.ForwardRefExoticComponent<GeezInputProps & React.RefAttributes<HTMLInputElement>>;

package/dist/components/geez-textarea.d.ts

@@ -0,0 +1,55 @@
+import { default as React } from 'react';
+/**
+ * Props for the GeezTextArea component
+ * Extends all standard HTML textarea attributes
+ */
+export interface GeezTextAreaProps extends React.TextareaHTMLAttributes<HTMLTextAreaElement> {
+    /**
+     * Whether Geez input mode is enabled by default
+     * @default true
+     */
+    defaultGeez?: boolean;
+    /**
+     * Additional CSS classes to apply to the textarea wrapper
+     */
+    className?: string;
+}
+/**
+ * Styled textarea component with built-in Geez phonetic keyboard support
+ *
+ * Features:
+ * - Toggle button to switch between Geez and English input modes
+ * - Phonetic transformation for longer text
+ * - Full support for controlled and uncontrolled component patterns
+ * - Forward ref support for form libraries
+ * - Styled with a classic paper and ink aesthetic
+ * - Minimum height of 150px for comfortable writing
+ *
+ * @example
+ * \`\`\`tsx
+ * // Basic usage
+ * <GeezTextArea placeholder="Write your story..." rows={5} />
+ * \`\`\`
+ *
+ * @example
+ * \`\`\`tsx
+ * // Controlled component
+ * function MyForm() {
+ *   const [content, setContent] = useState('')
+ *   return (
+ *     <GeezTextArea
+ *       value={content}
+ *       onChange={(e) => setContent(e.target.value)}
+ *       placeholder="Enter your text"
+ *     />
+ *   )
+ * }
+ * \`\`\`
+ *
+ * @example
+ * \`\`\`tsx
+ * // Start with English mode
+ * <GeezTextArea defaultGeez={false} placeholder="Type here..." />
+ * \`\`\`
+ */
+export declare const GeezTextArea: React.ForwardRefExoticComponent<GeezTextAreaProps & React.RefAttributes<HTMLTextAreaElement>>;

package/dist/components/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Geez Library React Components
+ *
+ * This module exports pre-styled React components with built-in
+ * Geez phonetic keyboard support.
+ *
+ * @module components
+ */
+export { GeezInput } from './geez-input';
+export { GeezTextArea } from './geez-textarea';
+export type { GeezInputProps } from './geez-input';
+export type { GeezTextAreaProps } from './geez-textarea';

package/dist/engine.d.ts

@@ -0,0 +1,67 @@
+import { EngineResult } from './types';
+/**
+ * Core transformation engine for converting Latin phonetic input to Geez script
+ *
+ * This engine handles the complex rules of Geez syllabic writing system where
+ * consonants combine with vowels to form syllables. It processes text character
+ * by character, applying transformations based on context and phonetic rules.
+ *
+ * @example
+ * \`\`\`ts
+ * const result = GeezEngine.transform('h', '', 'a')
+ * // result.transformedValue === 'ሀ'
+ * // result.isReplacement === true
+ * \`\`\`
+ */
+export declare class GeezEngine {
+    /**
+     * Transform input text based on a new key press
+     *
+     * The transformation process follows these rules in order:
+     * 1. Check for punctuation combinations (: + : → ።)
+     * 2. Check for multi-character consonants (s + h → ሽ)
+     * 3. Check for syllable modifications (ህ + a → ሀ)
+     * 4. Check for double vowel forms (ሀ + a → ሃ)
+     * 5. Check for new consonants (h → ህ)
+     * 6. Pass through unrecognized characters
+     *
+     * @param textBeforeCursor - Text content before the cursor position
+     * @param textAfterCursor - Text content after the cursor position
+     * @param key - The character key that was pressed
+     * @returns Transformation result with new text and cursor position
+     *
+     * @example
+     * \`\`\`ts
+     * // Simple consonant
+     * GeezEngine.transform('', '', 'h')
+     * // → { transformedValue: 'ህ', newCursorPosition: 1, isReplacement: false }
+     *
+     * // Syllable formation
+     * GeezEngine.transform('ህ', '', 'a')
+     * // → { transformedValue: 'ሀ', newCursorPosition: 1, isReplacement: true }
+     *
+     * // Multi-character consonant
+     * GeezEngine.transform('ስ', '', 'h')
+     * // → { transformedValue: 'ሽ', newCursorPosition: 1, isReplacement: true }
+     * \`\`\`
+     */
+    static transform(textBeforeCursor: string, textAfterCursor: string, key: string): EngineResult;
+    /**
+     * Find the base consonant form (ስድስት/sadis form) for a given character
+     *
+     * This method searches through the syllable mappings to find which base
+     * consonant a character belongs to, even if it's a modified form.
+     *
+     * @param char - The character to find the base form for
+     * @returns The base consonant character, or null if not found
+     * @private
+     *
+     * @example
+     * \`\`\`ts
+     * GeezEngine.findSadisBase('ሀ') // returns 'አ' (base for ሀ)
+     * GeezEngine.findSadisBase('ላ') // returns 'ል' (base for ላ)
+     * GeezEngine.findSadisBase('x') // returns null (not a Geez character)
+     * \`\`\`
+     */
+    private static findSadisBase;
+}

package/dist/main.d.ts

@@ -0,0 +1,53 @@
+/**
+ * @packageDocumentation
+ * Geez Input Library - Phonetic keyboard support for Geez/Ethiopic script in React
+ *
+ * This library provides React components and hooks for typing in Geez (Ethiopic) script
+ * using Latin phonetic characters. It supports Amharic, Tigrinya, and other languages
+ * written in the Geez script.
+ *
+ * ## Quick Start
+ *
+ * \`\`\`tsx
+ * import { GeezInput, GeezTextArea, useGeez } from 'geez-input'
+ *
+ * function App() {
+ *   return (
+ *     <div>
+ *       <GeezInput placeholder="Type your name..." />
+ *       <GeezTextArea placeholder="Write your story..." />
+ *     </div>
+ *   )
+ * }
+ * \`\`\`
+ *
+ * ## Main Exports
+ *
+ * ### Components
+ * - {@link GeezInput} - Styled input with Geez keyboard
+ * - {@link GeezTextArea} - Styled textarea with Geez keyboard
+ *
+ * ### Hooks
+ * - {@link useGeez} - Hook for custom implementations
+ *
+ * ### Engine
+ * - {@link GeezEngine} - Core transformation engine
+ *
+ * ### Types
+ * - {@link GeezOptions} - Configuration options
+ * - {@link EngineResult} - Transformation result
+ * - {@link PhoneticMap} - Character mapping type
+ * - {@link SyllableMap} - Syllable mapping type
+ *
+ * ### Mappings
+ * - {@link CONSONANTS} - Base consonant mappings
+ * - {@link SYLLABLES} - Syllable form mappings
+ * - {@link PUNCTUATION} - Punctuation mappings
+ * - {@link MULTI_CONSONANTS} - Multi-character consonants
+ */
+export * from './engine';
+export * from './use-geez';
+export * from './types';
+export * from './mapping';
+export * from './components/geez-input';
+export * from './components/geez-textarea';

package/dist/main.js

@@ -0,0 +1,628 @@
+import { useCallback as K, forwardRef as A, useState as y } from "react";
+import { jsxs as v, jsx as g } from "react/jsx-runtime";
+const f = {
+  h: "ህ",
+  l: "ል",
+  m: "ም",
+  r: "ር",
+  s: "ስ",
+  rR: "ር",
+  sh: "ሽ",
+  q: "ቅ",
+  b: "ብ",
+  t: "ት",
+  ch: "ች",
+  n: "ን",
+  gn: "ኝ",
+  N: "ኝ",
+  k: "ክ",
+  w: "ው",
+  z: "ዝ",
+  zh: "ዥ",
+  y: "ይ",
+  d: "ድ",
+  j: "ጅ",
+  g: "ግ",
+  T: "ጥ",
+  C: "ጭ",
+  P: "ጵ",
+  S: "ጽ",
+  f: "ፍ",
+  p: "ፕ",
+  v: "ቭ",
+  x: "ኽ",
+  H: "ኃ",
+  a: "አ",
+  u: "ኡ",
+  i: "ኢ",
+  e: "እ",
+  o: "ኦ",
+  A: "ኣ",
+  E: "ኤ",
+  O: "ዖ"
+}, r = {
+  አ: {
+    a: "አ",
+    e: "አ",
+    u: "ኡ",
+    i: "ኢ",
+    aa: "ኣ",
+    A: "ኣ",
+    ee: "ኤ",
+    E: "ኤ",
+    o: "ኦ"
+  },
+  ህ: {
+    a: "ሀ",
+    e: "ሀ",
+    u: "ሁ",
+    i: "ሂ",
+    aa: "ሃ",
+    A: "ሃ",
+    ee: "ሄ",
+    E: "ሄ",
+    o: "ሆ"
+  },
+  ኃ: {
+    a: "ኃ",
+    e: "ኃ",
+    u: "ኁ",
+    i: "ኂ",
+    aa: "ኃ",
+    A: "ኃ",
+    ee: "ኄ",
+    E: "ኄ",
+    o: "ኆ"
+  },
+  ል: {
+    a: "ለ",
+    e: "ለ",
+    u: "ሉ",
+    i: "ሊ",
+    aa: "ላ",
+    A: "ላ",
+    ee: "ሌ",
+    E: "ሌ",
+    o: "ሎ",
+    ua: "ሏ"
+  },
+  ም: {
+    a: "መ",
+    e: "መ",
+    u: "ሙ",
+    i: "ሚ",
+    aa: "ማ",
+    A: "ማ",
+    ee: "ሜ",
+    E: "ሜ",
+    o: "ሞ",
+    ua: "ሟ"
+  },
+  ር: {
+    a: "ረ",
+    e: "ረ",
+    u: "ሩ",
+    i: "ሪ",
+    aa: "ራ",
+    A: "ራ",
+    ee: "ሬ",
+    E: "ሬ",
+    o: "ሮ",
+    ua: "ሯ"
+  },
+  ስ: {
+    a: "ሰ",
+    e: "ሰ",
+    u: "ሱ",
+    i: "ሲ",
+    aa: "ሳ",
+    A: "ሳ",
+    ee: "ሴ",
+    E: "ሴ",
+    o: "ሶ",
+    ua: "ሷ"
+  },
+  ሽ: {
+    a: "ሸ",
+    e: "ሸ",
+    u: "ሹ",
+    i: "ሺ",
+    aa: "ሻ",
+    A: "ሻ",
+    ee: "ሼ",
+    E: "ሼ",
+    o: "ሾ",
+    ua: "ሿ"
+  },
+  ቅ: {
+    a: "ቀ",
+    e: "ቀ",
+    u: "ቁ",
+    i: "ቂ",
+    aa: "ቃ",
+    A: "ቃ",
+    ee: "ቄ",
+    E: "ቄ",
+    o: "ቆ",
+    ua: "ቋ"
+  },
+  ብ: {
+    a: "በ",
+    e: "በ",
+    u: "ቡ",
+    i: "ቢ",
+    aa: "ባ",
+    A: "ባ",
+    ee: "ቤ",
+    E: "ቤ",
+    o: "ቦ",
+    ua: "ቧ"
+  },
+  ት: {
+    a: "ተ",
+    e: "ተ",
+    u: "ቱ",
+    i: "ቲ",
+    aa: "ታ",
+    A: "ታ",
+    ee: "ቴ",
+    E: "ቴ",
+    o: "ቶ",
+    ua: "ቷ"
+  },
+  ች: {
+    a: "ቸ",
+    e: "ቸ",
+    u: "ቹ",
+    i: "ቺ",
+    aa: "ቻ",
+    A: "ቻ",
+    ee: "ቼ",
+    E: "ቼ",
+    o: "ቾ",
+    ua: "ቿ"
+  },
+  ን: {
+    a: "ነ",
+    e: "ነ",
+    u: "ኑ",
+    i: "ኒ",
+    aa: "ና",
+    A: "ና",
+    ee: "ኔ",
+    E: "ኔ",
+    o: "ኖ",
+    ua: "ኗ"
+  },
+  ኝ: {
+    a: "ኘ",
+    e: "ኘ",
+    u: "ኙ",
+    i: "ኚ",
+    aa: "ኛ",
+    A: "ኛ",
+    ee: "ኜ",
+    E: "ኜ",
+    o: "ኞ",
+    ua: "ኟ"
+  },
+  ክ: {
+    a: "ከ",
+    e: "ከ",
+    u: "ኩ",
+    i: "ኪ",
+    aa: "ካ",
+    A: "ካ",
+    ee: "ኬ",
+    E: "ኬ",
+    o: "ኮ",
+    ua: "ኳ"
+  },
+  ው: {
+    a: "ወ",
+    e: "ወ",
+    u: "ዉ",
+    i: "ዊ",
+    aa: "ዋ",
+    A: "ዋ",
+    ee: "ዌ",
+    E: "ዌ",
+    o: "ዎ"
+  },
+  ዝ: {
+    a: "ዘ",
+    e: "ዘ",
+    u: "ዙ",
+    i: "ዚ",
+    aa: "ዛ",
+    A: "ዛ",
+    ee: "ዜ",
+    E: "ዜ",
+    o: "ዞ",
+    ua: "ዟ"
+  },
+  ዥ: {
+    a: "ዠ",
+    e: "ዠ",
+    u: "ዡ",
+    i: "ዢ",
+    aa: "ዣ",
+    A: "ዣ",
+    ee: "ዤ",
+    E: "ዤ",
+    o: "ዦ",
+    ua: "ዧ"
+  },
+  ይ: {
+    a: "የ",
+    e: "የ",
+    u: "ዩ",
+    i: "ዪ",
+    aa: "ያ",
+    A: "ያ",
+    ee: "ዬ",
+    E: "ዬ",
+    o: "ዮ"
+  },
+  ጅ: {
+    a: "ጀ",
+    e: "ጀ",
+    u: "ጁ",
+    i: "ጂ",
+    aa: "ጃ",
+    A: "ጃ",
+    ee: "ጄ",
+    E: "ጄ",
+    o: "ጆ",
+    ua: "ጇ"
+  },
+  ድ: {
+    a: "ደ",
+    e: "ደ",
+    u: "ዱ",
+    i: "ዲ",
+    aa: "ዳ",
+    A: "ዳ",
+    ee: "ዴ",
+    E: "ዴ",
+    o: "ዶ",
+    ua: "ዷ"
+  },
+  ግ: {
+    a: "ገ",
+    e: "ገ",
+    u: "ጉ",
+    i: "ጊ",
+    aa: "ጋ",
+    A: "ጋ",
+    ee: "ጌ",
+    E: "ጌ",
+    o: "ጎ",
+    ua: "ጓ"
+  },
+  ጥ: {
+    a: "ጠ",
+    e: "ጠ",
+    u: "ጡ",
+    i: "ጢ",
+    aa: "ጣ",
+    A: "ጣ",
+    ee: "ጤ",
+    E: "ጤ",
+    o: "ጦ",
+    ua: "ጧ"
+  },
+  ጭ: {
+    a: "ጨ",
+    e: "ጨ",
+    u: "ጩ",
+    i: "ጪ",
+    aa: "ጫ",
+    A: "ጫ",
+    ee: "ጬ",
+    E: "ጬ",
+    o: "ጮ",
+    ua: "ቿ"
+  },
+  ጵ: {
+    a: "ጰ",
+    e: "ጰ",
+    u: "ጱ",
+    i: "ጲ",
+    aa: "ጳ",
+    A: "ጳ",
+    ee: "ጴ",
+    E: "ጴ",
+    o: "ጶ",
+    ua: "ፗ"
+  },
+  ጽ: {
+    a: "ጸ",
+    e: "ጸ",
+    u: "ጹ",
+    i: "ጺ",
+    aa: "ጻ",
+    A: "ጻ",
+    ee: "ጼ",
+    E: "ጼ",
+    o: "ጾ",
+    ua: "ጿ"
+  },
+  ፍ: {
+    a: "ፈ",
+    e: "ፈ",
+    u: "ፉ",
+    i: "ፊ",
+    aa: "ፋ",
+    A: "ፋ",
+    ee: "ፌ",
+    E: "ፌ",
+    o: "ፎ",
+    ua: "ፏ"
+  },
+  ፕ: {
+    a: "ፐ",
+    e: "ፐ",
+    u: "ፑ",
+    i: "ፒ",
+    aa: "ፓ",
+    A: "ፓ",
+    ee: "ፔ",
+    E: "ፔ",
+    o: "ፖ",
+    ua: "ፗ"
+  },
+  ቭ: {
+    a: "ቨ",
+    e: "ቨ",
+    u: "ቩ",
+    i: "ቪ",
+    aa: "ቫ",
+    A: "ቫ",
+    ee: "ቬ",
+    E: "ቬ",
+    o: "ቮ",
+    ua: "ቯ"
+  }
+}, w = {
+  ስh: "ሽ",
+  ችh: "ች",
+  ንy: "ኝ",
+  ዝh: "ዥ",
+  ጽh: "ፁ"
+}, m = {
+  ":": "፡",
+  "፡:": "።",
+  "።:": "፡",
+  ",": "፣",
+  "፣,": "፤",
+  ";": "፤"
+};
+class S {
+  /**
+   * Transform input text based on a new key press
+   *
+   * The transformation process follows these rules in order:
+   * 1. Check for punctuation combinations (: + : → ።)
+   * 2. Check for multi-character consonants (s + h → ሽ)
+   * 3. Check for syllable modifications (ህ + a → ሀ)
+   * 4. Check for double vowel forms (ሀ + a → ሃ)
+   * 5. Check for new consonants (h → ህ)
+   * 6. Pass through unrecognized characters
+   *
+   * @param textBeforeCursor - Text content before the cursor position
+   * @param textAfterCursor - Text content after the cursor position
+   * @param key - The character key that was pressed
+   * @returns Transformation result with new text and cursor position
+   *
+   * @example
+   * \`\`\`ts
+   * // Simple consonant
+   * GeezEngine.transform('', '', 'h')
+   * // → { transformedValue: 'ህ', newCursorPosition: 1, isReplacement: false }
+   *
+   * // Syllable formation
+   * GeezEngine.transform('ህ', '', 'a')
+   * // → { transformedValue: 'ሀ', newCursorPosition: 1, isReplacement: true }
+   *
+   * // Multi-character consonant
+   * GeezEngine.transform('ስ', '', 'h')
+   * // → { transformedValue: 'ሽ', newCursorPosition: 1, isReplacement: true }
+   * \`\`\`
+   */
+  static transform(e, a, t) {
+    const n = e.slice(-1), l = n + t;
+    if (m[l])
+      return {
+        transformedValue: e.slice(0, -1) + m[l] + a,
+        newCursorPosition: e.length,
+        isReplacement: !0
+      };
+    if (m[t])
+      return {
+        transformedValue: e + m[t] + a,
+        newCursorPosition: e.length + 1,
+        isReplacement: !1
+      };
+    if (w[l])
+      return {
+        transformedValue: e.slice(0, -1) + w[l] + a,
+        newCursorPosition: e.length,
+        isReplacement: !0
+      };
+    if (r[n] && r[n][t])
+      return {
+        transformedValue: e.slice(0, -1) + r[n][t] + a,
+        newCursorPosition: e.length,
+        isReplacement: !0
+      };
+    if (["a", "e", "i"].includes(t)) {
+      const o = this.findSadisBase(n);
+      if (o && r[o]) {
+        const i = t + t;
+        if (r[o][i])
+          return {
+            transformedValue: e.slice(0, -1) + r[o][i] + a,
+            newCursorPosition: e.length,
+            isReplacement: !0
+          };
+      }
+    }
+    return f[t] ? {
+      transformedValue: e + f[t] + a,
+      newCursorPosition: e.length + 1,
+      isReplacement: !1
+    } : {
+      transformedValue: e + t + a,
+      newCursorPosition: e.length + 1,
+      isReplacement: !1
+    };
+  }
+  /**
+   * Find the base consonant form (ስድስት/sadis form) for a given character
+   *
+   * This method searches through the syllable mappings to find which base
+   * consonant a character belongs to, even if it's a modified form.
+   *
+   * @param char - The character to find the base form for
+   * @returns The base consonant character, or null if not found
+   * @private
+   *
+   * @example
+   * \`\`\`ts
+   * GeezEngine.findSadisBase('ሀ') // returns 'አ' (base for ሀ)
+   * GeezEngine.findSadisBase('ላ') // returns 'ል' (base for ላ)
+   * GeezEngine.findSadisBase('x') // returns null (not a Geez character)
+   * \`\`\`
+   */
+  static findSadisBase(e) {
+    for (const [a, t] of Object.entries(r))
+      if (a === e || Object.values(t).includes(e)) return a;
+    return null;
+  }
+}
+const z = (c = {}) => {
+  const { enabled: e = !0, onTransform: a } = c;
+  return { onKeyDown: K(
+    (n) => {
+      if (!e || [
+        "Backspace",
+        "Delete",
+        "ArrowLeft",
+        "ArrowRight",
+        "ArrowUp",
+        "ArrowDown",
+        "Home",
+        "End",
+        "Tab",
+        "Enter",
+        "Escape",
+        "PageUp",
+        "PageDown"
+      ].includes(n.key) || n.ctrlKey || n.metaKey || n.key.length !== 1 || n.altKey) return;
+      n.preventDefault();
+      const o = n.currentTarget, { selectionStart: i, selectionEnd: p, value: d } = o, b = d.substring(0, i || 0), E = d.substring(p || 0), u = S.transform(b, E, n.key), s = Object.getOwnPropertyDescriptor(o.constructor.prototype, "value");
+      s && s.set ? s.set.bind(o)(u.transformedValue) : o.value = u.transformedValue;
+      let h;
+      typeof InputEvent < "u" ? h = new InputEvent("input", {
+        bubbles: !0,
+        cancelable: !0,
+        inputType: "insertText",
+        data: n.key
+      }) : h = new Event("input", { bubbles: !0, cancelable: !0 }), o.dispatchEvent(h);
+      const N = new Event("change", {
+        bubbles: !0,
+        cancelable: !0
+      });
+      o.dispatchEvent(N), requestAnimationFrame(() => {
+        if (document.activeElement === o)
+          try {
+            o.setSelectionRange(u.newCursorPosition, u.newCursorPosition);
+          } catch {
+          }
+      }), a && a(u);
+    },
+    [e, a]
+  ) };
+}, P = A(
+  ({ defaultGeez: c = !0, className: e, onChange: a, onKeyDown: t, value: n, ...l }, o) => {
+    const [i, p] = y(c), d = {
+      ...l,
+      ...n !== void 0 && { value: n }
+    }, { onKeyDown: b } = z({ enabled: i });
+    return /* @__PURE__ */ v("div", { className: "relative group w-full", children: [
+      /* @__PURE__ */ g(
+        "input",
+        {
+          ...d,
+          ref: o,
+          onKeyDown: (s) => {
+            b(s), t && t(s);
+          },
+          onChange: (s) => {
+            a && a(s);
+          },
+          className: `w-full bg-paper border-2 border-gold/20 focus:border-crimson outline-none p-4 font-serif text-lg transition-all ${e || ""}`
+        }
+      ),
+      /* @__PURE__ */ g(
+        "button",
+        {
+          type: "button",
+          onClick: () => p(!i),
+          className: `absolute right-4 top-1/2 -translate-y-1/2 px-3 py-1.5 rounded-md transition-all z-10 font-semibold text-sm ${i ? "bg-crimson text-white" : "bg-gold/10 text-gold"}`,
+          title: i ? "Switch to English" : "Switch to Ge'ez",
+          tabIndex: -1,
+          children: i ? "አማ" : "EN"
+        }
+      )
+    ] });
+  }
+);
+P.displayName = "GeezInput";
+const T = A(
+  ({ defaultGeez: c = !0, className: e, onChange: a, onKeyDown: t, value: n, ...l }, o) => {
+    const [i, p] = y(c), d = {
+      ...l,
+      ...n !== void 0 && { value: n }
+    }, { onKeyDown: b } = z({ enabled: i }), E = (s) => {
+      b(s), t && t(s);
+    }, u = (s) => {
+      a && a(s);
+    };
+    return /* @__PURE__ */ v("div", { className: `relative group w-full ${e || ""}`, children: [
+      /* @__PURE__ */ g(
+        "textarea",
+        {
+          ...d,
+          ref: o,
+          onKeyDown: E,
+          onChange: u,
+          className: `w-full bg-paper border-2 border-gold/20 focus:border-crimson outline-none p-6 font-serif text-lg leading-relaxed transition-all min-h-[150px] ${e || ""}`
+        }
+      ),
+      /* @__PURE__ */ g(
+        "button",
+        {
+          type: "button",
+          onClick: () => p(!i),
+          className: `absolute right-4 top-4 px-3 py-1.5 rounded-md transition-all z-10 font-semibold text-sm ${i ? "bg-crimson text-white" : "bg-gold/10 text-gold"}`,
+          title: i ? "Switch to English" : "Switch to Ge'ez",
+          tabIndex: -1,
+          children: i ? "አማ" : "EN"
+        }
+      )
+    ] });
+  }
+);
+T.displayName = "GeezTextArea";
+export {
+  f as CONSONANTS,
+  S as GeezEngine,
+  P as GeezInput,
+  T as GeezTextArea,
+  w as MULTI_CONSONANTS,
+  m as PUNCTUATION,
+  r as SYLLABLES,
+  z as useGeez
+};

package/dist/mapping.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Base consonant characters in Geez script
+ * Maps Latin phonetic characters to their corresponding Geez consonants (6th form/ስድስት)
+ *
+ * @example
+ * \`\`\`ts
+ * CONSONANTS['h'] // returns 'ህ'
+ * CONSONANTS['sh'] // returns 'ሽ'
+ * \`\`\`
+ */
+export declare const CONSONANTS: Record<string, string>;
+/**
+ * Syllable forms for each consonant with vowel modifications
+ * Each consonant base has multiple forms based on the following vowel
+ *
+ * Vowel order (traditional):
+ * - a/e (ግዕዝ/Geez) - base form
+ * - u (ካዕብ/Kaeb) - u modification
+ * - i (ሳልስ/Salis) - i modification
+ * - aa/A (ራብዕ/Rabee) - aa modification
+ * - ee/E (ኃምስ/Hamis) - ee modification
+ * - o (ሳድስ/Sadis) - o modification
+ * - ua (ሳብዕ/Sabe) - ua modification (not available for all)
+ *
+ * @example
+ * \`\`\`ts
+ * SYLLABLES['ህ']['a'] // returns 'ሀ'
+ * SYLLABLES['ል']['ua'] // returns 'ሏ'
+ * \`\`\`
+ */
+export declare const SYLLABLES: Record<string, Record<string, string>>;
+/**
+ * Multi-character consonant combinations
+ * Handles digraphs and special character sequences
+ *
+ * @example
+ * \`\`\`ts
+ * MULTI_CONSONANTS['ስh'] // returns 'ሽ' (sh sound)
+ * \`\`\`
+ */
+export declare const MULTI_CONSONANTS: Record<string, string>;
+/**
+ * Punctuation mark mappings from Latin to Geez
+ * Supports sequential input for different punctuation forms
+ *
+ * @example
+ * \`\`\`ts
+ * PUNCTUATION[':'] // returns '፡' (word separator)
+ * PUNCTUATION['፡:'] // returns '።' (sentence ending)
+ * \`\`\`
+ */
+export declare const PUNCTUATION: Record<string, string>;

package/dist/types.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Phonetic character mapping from Latin to Geez script
+ * @example
+ * ```ts
+ * const mapping: PhoneticMap = { 'h': 'ህ', 'l': 'ል' }
+ * ```
+ */
+export type PhoneticMap = Record<string, string>;
+/**
+ * Syllable mapping with vowel modifications for each consonant
+ * @example
+ * ```ts
+ * const syllables: SyllableMap = {
+ *   'ህ': { 'a': 'ሀ', 'u': 'ሁ', 'i': 'ሂ' }
+ * }
+ * ```
+ */
+export type SyllableMap = Record<string, Record<string, string>>;
+/**
+ * Result of a character transformation operation
+ */
+export interface EngineResult {
+    /** The complete transformed text value */
+    transformedValue: string;
+    /** The new cursor position after transformation */
+    newCursorPosition: number;
+    /** Whether this transformation replaced existing characters */
+    isReplacement: boolean;
+}
+/**
+ * Keyboard configuration settings
+ * @deprecated Not currently used in the library
+ */
+export interface KeyboardConfig {
+    /** Whether the Geez keyboard is enabled */
+    enabled: boolean;
+    /** The phonetic standard to use */
+    standard: "GFF" | "Custom";
+}
+/**
+ * Configuration options for the useGeez hook
+ */
+export interface GeezOptions {
+    /**
+     * Callback function triggered after each transformation
+     * @param result - The result of the transformation
+     */
+    onTransform?: (result: EngineResult) => void;
+    /**
+     * Whether Geez transformation is enabled
+     * @default true
+     */
+    enabled?: boolean;
+}
+/**
+ * Geez transformation statistics for a single operation
+ */
+export interface TransformStats {
+    /** Input character that triggered the transformation */
+    inputChar: string;
+    /** Output character(s) after transformation */
+    outputChar: string;
+    /** Type of transformation performed */
+    transformType: "consonant" | "syllable" | "punctuation" | "multi-consonant" | "double-vowel" | "passthrough";
+}

package/dist/use-geez.d.ts

@@ -0,0 +1,43 @@
+import { default as React } from 'react';
+import { GeezOptions } from './types';
+/**
+ * React hook for adding Geez phonetic keyboard functionality to input elements
+ *
+ * This hook intercepts keyboard events and transforms Latin characters to Geez script
+ * in real-time. It properly handles controlled and uncontrolled React components,
+ * cursor positioning, and form events.
+ *
+ * @param options - Configuration options for the hook
+ * @returns Object containing the onKeyDown event handler
+ *
+ * @example
+ * \`\`\`tsx
+ * function MyInput() {
+ *   const { onKeyDown } = useGeez({
+ *     enabled: true,
+ *     onTransform: (result) => console.log('Transformed:', result)
+ *   })
+ *   return <input onKeyDown={onKeyDown} />
+ * }
+ * \`\`\`
+ *
+ * @example
+ * \`\`\`tsx
+ * // With controlled component
+ * function ControlledInput() {
+ *   const [value, setValue] = useState('')
+ *   const { onKeyDown } = useGeez()
+ *
+ *   return (
+ *     <input
+ *       value={value}
+ *       onChange={(e) => setValue(e.target.value)}
+ *       onKeyDown={onKeyDown}
+ *     />
+ *   )
+ * }
+ * \`\`\`
+ */
+export declare const useGeez: (options?: GeezOptions) => {
+    onKeyDown: (e: React.KeyboardEvent<HTMLTextAreaElement | HTMLInputElement>) => void;
+};

package/dist/vite-env.d.d.ts

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "geez-input",
+  "version": "1.0.0",
+  "description": "Type-safe React library for Geez (Ethiopic) script input with phonetic keyboard support",
+  "keywords": [
+    "geez",
+    "ethiopic",
+    "amharic",
+    "tigrinya",
+    "react",
+    "typescript",
+    "keyboard",
+    "input",
+    "phonetic"
+  ],
+  "homepage": "https://github.com/yourusername/geez-library#readme",
+  "bugs": {
+    "url": "https://github.com/yourusername/geez-library/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/yourusername/geez-library.git"
+  },
+  "license": "MIT",
+  "author": "Your Name",
+  "sideEffects": [
+    "**/*.css"
+  ],
+  "type": "module",
+  "main": "./dist/main.js",
+  "module": "./dist/main.js",
+  "types": "./dist/main.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/main.js",
+      "types": "./dist/main.d.ts"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "npx vite build",
+    "dev": "npx vite",
+    "preview": "npx vite preview",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "@types/node": "^22",
+    "@types/react": "^19",
+    "@types/react-dom": "^19",
+    "@vitejs/plugin-react": "5.1.2",
+    "react": "19.2.0",
+    "react-dom": "19.2.0",
+    "typescript": "^5",
+    "vite": "7.3.0",
+    "vite-plugin-dts": "4.5.4",
+    "vite-plugin-lib-inject-css": "2.2.2"
+  },
+  "peerDependencies": {
+    "react": "^18.0.0 || ^19.0.0",
+    "react-dom": "^18.0.0 || ^19.0.0"
+  }
+}