Add date-only conversion functions and improve docs

Introduced GregorianToKurdishDate and KurdishToGregorianDate functions for direct date-only conversions without time.Time. Updated README with expanded usage examples, dialect and epoch handling, formatting, error handling, and new function documentation. Standardized Kurdish digit formatting in format.go.

Author: rojcode

README.md

@@ -21,6 +21,8 @@ go get github.com/rojcode/kurdical
 
 ## Usage
 
+### Basic Conversion
+
 ```go
 package main
 
@@ -35,30 +37,119 @@ func main() {
     t := time.Date(2023, 3, 21, 0, 0, 0, 0, time.UTC)
     k := kurdical.GregorianToKurdish(t, kurdical.Sorani, kurdical.MedianKingdom)
     fmt.Printf("Kurdish date: %d-%d-%d %s\n", k.Year, k.Month, k.Day, k.MonthName)
+    // Output: Kurdish date: 2723-1-1 خاکه‌لێوه
+}
+```
+
+### Round Trip Conversion
+
+```go
+// Convert Kurdish to Gregorian
+g, err := kurdical.KurdishToGregorian(k)
+if err != nil {
+    fmt.Println(err)
+} else {
+    fmt.Printf("Gregorian date: %s\n", g.Format("2006-01-02"))
+    // Output: Gregorian date: 2023-03-21
+}
+```
+
+### Different Dialects
+
+```go
+// Sorani dialect
+kSorani := kurdical.GregorianToKurdish(t, kurdical.Sorani, kurdical.MedianKingdom)
+fmt.Printf("Sorani: %s\n", kSorani.MonthName) // خاکه‌لێوه
+
+// Kurmanji dialect
+kKurmanji := kurdical.GregorianToKurdish(t, kurdical.Kurmanji, kurdical.MedianKingdom)
+fmt.Printf("Kurmanji: %s\n", kKurmanji.MonthName) // نیسان
+
+// Laki dialect
+kLaki := kurdical.GregorianToKurdish(t, kurdical.Laki, kurdical.MedianKingdom)
+fmt.Printf("Laki: %s\n", kLaki.MonthName) // په‌نجه
+```
+
+### Different Epochs
+
+```go
+// Median Kingdom epoch
+kMedian := kurdical.GregorianToKurdish(t, kurdical.Sorani, kurdical.MedianKingdom)
+fmt.Printf("Median Kingdom: %d\n", kMedian.Year) // 2723
+
+// Fall of Nineveh epoch
+kNineveh := kurdical.GregorianToKurdish(t, kurdical.Sorani, kurdical.FallOfNineveh)
+fmt.Printf("Fall of Nineveh: %d\n", kNineveh.Year) // 2635
+```
+
+### Formatting with Kurdish Digits
+
+```go
+formatted, err := k.KFormat("2006-01-02 January")
+if err != nil {
+    fmt.Println("Error:", err)
+} else {
+    fmt.Printf("Formatted: %s\n", formatted)
+    // Output: Formatted: ٢٧٢٣-٠١-٠١ خاکه‌لێوه
+}
+```
 
-    // Convert Kurdish to Gregorian
-    g, err := kurdical.KurdishToGregorian(k)
-    if err != nil {
-        fmt.Println(err)
-    } else {
-        fmt.Printf("Gregorian date: %s\n", g.Format("2006-01-02"))
-    }
-
-    // Create a specific Kurdish date and convert to Gregorian
-    // Note: Dialect is optional and not used in conversion, only Epoch matters
-    specificKurdish := kurdical.KurdishDate{
-        Year:    2725,
-        Month:   9,
-        Day:     24,
-        Dialect: kurdical.Sorani, // Optional
-        Epoch:   kurdical.MedianKingdom,
-    }
-    gregorianSpecific, err := kurdical.KurdishToGregorian(specificKurdish)
-    if err != nil {
-        fmt.Println("Error:", err)
-    } else {
-        fmt.Printf("Kurdish 2725-09-24 to Gregorian: %s\n", gregorianSpecific.Format("2006-01-02"))
-    }
+### Weekday Display
+
+```go
+fmt.Printf("Weekday: %s\n", kurdical.WeekdayNames[k.Weekday])
+// Output: Weekday: سێشەممە (for Tuesday)
+```
+
+### Creating Kurdish Date Manually
+
+```go
+// Create a specific Kurdish date and convert to Gregorian
+specificKurdish := kurdical.KurdishDate{
+    Year:    2725,
+    Month:   9,
+    Day:     24,
+    Dialect: kurdical.Sorani, // Optional
+    Epoch:   kurdical.MedianKingdom,
+}
+gregorianSpecific, err := kurdical.KurdishToGregorian(specificKurdish)
+if err != nil {
+    fmt.Println("Error:", err)
+} else {
+    fmt.Printf("Kurdish 2725-09-24 to Gregorian: %s\n", gregorianSpecific.Format("2006-01-02"))
+    // Output: Kurdish 2725-09-24 to Gregorian: 2025-12-15
+}
+```
+
+### Date-Only Functions
+
+```go
+// Using date-only functions without time.Time
+k := kurdical.GregorianToKurdishDate(2023, 3, 21, kurdical.Sorani, kurdical.MedianKingdom)
+fmt.Printf("Kurdish: %d-%d-%d %s\n", k.Year, k.Month, k.Day, k.MonthName)
+
+gy, gm, gd, err := kurdical.KurdishToGregorianDate(k.Year, k.Month, k.Day, k.Epoch)
+if err != nil {
+    fmt.Println("Error:", err)
+} else {
+    fmt.Printf("Gregorian: %d-%d-%d\n", gy, gm, gd)
+    // Output: Gregorian: 2023-3-21
+}
+```
+
+### Error Handling
+
+```go
+// Invalid date
+invalidKurdish := kurdical.KurdishDate{
+    Year:  2725,
+    Month: 13, // Invalid month
+    Day:   24,
+    Epoch: kurdical.MedianKingdom,
+}
+_, err := kurdical.KurdishToGregorian(invalidKurdish)
+if err != nil {
+    fmt.Printf("Error: %s\n", err) // Error: invalid month: 13
 }
 ```
 
@@ -73,8 +164,10 @@ func main() {
 ### Functions
 
 - `GregorianToKurdish(t time.Time, dialect Dialect, epoch Epoch) KurdishDate`
+- `GregorianToKurdishDate(year, month, day int, dialect Dialect, epoch Epoch) KurdishDate`
 - `KurdishToGregorian(k KurdishDate) (time.Time, error)`
-- `(k KurdishDate) KFormat(layout string) (string, error)`: Formats the Kurdish date using Go time layout strings with Persian digits
+- `KurdishToGregorianDate(kYear, kMonth, kDay int, epoch Epoch) (int, int, int, error)`
+- `(k KurdishDate) KFormat(layout string) (string, error)`: Formats the Kurdish date using Go time layout strings with Kurdish digits
 
 ## Kurdish Calendar Details
 

format.go

@@ -275,15 +275,15 @@ func appendInt(b []byte, x int, width int) []byte {
 	for u >= 10 {
 		i--
 		q := u / 10
-		buf[i] = rune('۰' + u - q*10)
+		buf[i] = rune('٠' + u - q*10)
 		u = q
 	}
 	i--
-	buf[i] = rune('۰' + u)
+	buf[i] = rune('٠' + u)
 
 	// Add 0-padding.
 	for w := len(buf) - i; w < width; w++ {
-		b = append(b, []byte("۰")...)
+		b = append(b, []byte("٠")...)
 	}
 
 	return append(b, []byte(string(buf[i:]))...)
@@ -296,15 +296,15 @@ func formatNano(b []byte, nanosec uint, n int, trim bool) []byte {
 	var buf [9]rune
 	for start := len(buf); start > 0; {
 		start--
-		buf[start] = rune(u%10 + '۰')
+		buf[start] = rune(u%10 + '٠')
 		u /= 10
 	}
 
 	if n > 9 {
 		n = 9
 	}
 	if trim {
-		for n > 0 && buf[n-1] == '۰' {
+		for n > 0 && buf[n-1] == '٠' {
 			n--
 		}
 		if n == 0 {

kurdical.go

@@ -50,11 +50,17 @@ var epochOffsets = map[Epoch]int{
 // GregorianToKurdish converts a Gregorian time.Time to a KurdishDate.
 func GregorianToKurdish(t time.Time, dialect Dialect, epoch Epoch) KurdishDate {
 	year, month, day := t.Date()
-	sYear, sMonth, sDay := gregorianToSolarHijri(year, int(month), day)
+	return GregorianToKurdishDate(year, int(month), day, dialect, epoch)
+}
+
+// GregorianToKurdishDate converts Gregorian year, month, day to KurdishDate.
+func GregorianToKurdishDate(year, month, day int, dialect Dialect, epoch Epoch) KurdishDate {
+	sYear, sMonth, sDay := gregorianToSolarHijri(year, month, day)
 	kYear := sYear + epochOffsets[epoch]
 	monthName := monthNames[dialect][sMonth-1]
 
-	// Calculate Kurdish weekday: 1=Saturday, 2=Sunday, ..., 7=Friday
+	// Calculate weekday from Gregorian date
+	t := time.Date(year, time.Month(month), day, 0, 0, 0, 0, time.UTC)
 	weekday := int(t.Weekday())
 	switch weekday {
 	case 0: // Sunday
@@ -86,17 +92,26 @@ func GregorianToKurdish(t time.Time, dialect Dialect, epoch Epoch) KurdishDate {
 
 // KurdishToGregorian converts a KurdishDate to a Gregorian time.Time.
 func KurdishToGregorian(k KurdishDate) (time.Time, error) {
-	if k.Month < 1 || k.Month > 12 {
-		return time.Time{}, &ErrorInvalidMonth{Month: k.Month}
+	year, month, day, err := KurdishToGregorianDate(k.Year, k.Month, k.Day, k.Epoch)
+	if err != nil {
+		return time.Time{}, err
+	}
+	return time.Date(year, time.Month(month), day, 0, 0, 0, 0, time.UTC), nil
+}
+
+// KurdishToGregorianDate converts Kurdish year, month, day to Gregorian year, month, day.
+func KurdishToGregorianDate(kYear, kMonth, kDay int, epoch Epoch) (int, int, int, error) {
+	if kMonth < 1 || kMonth > 12 {
+		return 0, 0, 0, &ErrorInvalidMonth{Month: kMonth}
 	}
 	monthDays := []int{31, 31, 31, 31, 31, 31, 30, 30, 30, 30, 30, 29}
-	sYear := k.Year - epochOffsets[k.Epoch]
+	sYear := kYear - epochOffsets[epoch]
 	if isSolarHijriLeap(sYear) {
 		monthDays[11] = 30
 	}
-	if k.Day < 1 || k.Day > monthDays[k.Month-1] {
-		return time.Time{}, &ErrorInvalidDay{Day: k.Day}
+	if kDay < 1 || kDay > monthDays[kMonth-1] {
+		return 0, 0, 0, &ErrorInvalidDay{Day: kDay}
 	}
-	gYear, gMonth, gDay := solarHijriToGregorian(sYear, k.Month, k.Day)
-	return time.Date(gYear, time.Month(gMonth), gDay, 0, 0, 0, 0, time.UTC), nil
+	gYear, gMonth, gDay := solarHijriToGregorian(sYear, kMonth, kDay)
+	return gYear, gMonth, gDay, nil
 }