First version

fixed the bug where the "some text here" example would have spaces inserted inside when typing in a textbox

.gitignore

@@ -23,3 +23,6 @@ go.work.sum
 
 # env file
 .env
+
+# macOS
+.DS_Store

README.md

@@ -11,8 +11,12 @@ import (
 )
 
 func main() {
-	components := osui.NewRender()
+
-	components.Add(ui.Text("Hello, World!"))
+	app := ui.Div(
-	components.Render()
+		ui.Text("Hello, World!")
+	)
+
+	screen := osui.NewScreen(app)
+	screen.Run()
 }
 ```

colors/colors.go

@@ -0,0 +1,60 @@
+package colors
+
+import (
+	"fmt"
+	"regexp"
+	"strings"
+)
+
+const (
+	Reset     = "\x1b[0m"
+	Bold      = "\x1b[1m"
+	Underline = "\x1b[4m"
+	Italic    = "\x1b[3m"
+	Reverse   = "\x1b[7m"
+	Strike    = "\x1b[9m"
+
+	Black   = "\x1b[30m"
+	Red     = "\x1b[31m"
+	Green   = "\x1b[32m"
+	Yellow  = "\x1b[33m"
+	Blue    = "\x1b[34m"
+	Magenta = "\x1b[35m"
+	Cyan    = "\x1b[36m"
+	White   = "\x1b[37m"
+)
+
+func Rgb(r, g, b uint8) string {
+	return fmt.Sprintf("\x1b[38;2;%d;%d;%dm", r, g, b)
+}
+
+func AsBg(s string) string {
+	re, _ := regexp.Compile(`\x1b\[3([0-9]+)`)
+	return re.ReplaceAllStringFunc(s, func(match string) string {
+		groups := re.FindStringSubmatch(match)
+		if len(groups) >= 2 {
+			return fmt.Sprintf("\x1b[4%s", groups[1])
+		}
+		return match
+	})
+}
+
+
+func AsFg(s string) string {
+	re, _ := regexp.Compile(`\x1b\[4([0-9]+)`)
+	return re.ReplaceAllStringFunc(s, func(match string) string {
+		groups := re.FindStringSubmatch(match)
+		if len(groups) >= 2 {
+			return fmt.Sprintf("\x1b[3%s", groups[1])
+		}
+		return match
+	})
+}
+
+func Combine(s, s1 string) string {
+	if strings.Contains(s, Reset) {
+		return s + s1
+	} else {
+		return s1 + s
+	}
+}

example/main.go

@@ -0,0 +1,55 @@
+package main
+
+import (
+	"github.com/orus-dev/osui"
+	"github.com/orus-dev/osui/colors"
+	. "github.com/orus-dev/osui/ui"
+)
+
+func main() {
+	screen := osui.NewScreen(App())
+	screen.Run()
+}
+
+func App() *PaginatorComponent {
+	w, h := osui.GetTerminalSize()
+	return Paginator(
+		// Page 1
+		Div(
+			Text("Welcome to the example! The blue text on the bottom show the keybindings"),
+			WithPosition(0, h-2, Text(colors.Blue+"Next Page: Tab. Previous Page: shift + tab")),
+		),
+
+		// Page 2
+		Div(
+			WithPosition(0, 0, Text("This blue square is a div. A div stores multiple components into one")),
+			WithPosition((w-30)/2, (h-4)/2,
+				WithSize(30, 5,
+					WithStyle(&DivStyle{Outline: colors.Blue},
+						Div(WithPosition(4, 1, Button("Hello, World!", BtnParams{Width: 19}))),
+					))),
+			WithPosition(0, h-2, Text(colors.Blue+"Navigate: Ctrl+(W/A/S/D)")),
+		),
+
+		// Page 3
+		Div(
+			WithPosition(0, 0, Text("This is a InputBox. It takes user input just like a GUI. "+colors.Red+colors.Bold+"NOTE: This InputBox is inside a div")),
+			WithPosition((w-32)/2, (h-3)/2, InputBox(30)),
+			WithPosition(0, h-2, Text(colors.Blue+"Navigate: W/S. Select: Enter. Exit Menu: Q. ")),
+		),
+
+		// Page 4
+		Div(
+			WithPosition(0, 0, Text("This is a Button. To click it press Enter. "+colors.Red+colors.Bold+"NOTE: This Button is inside a div")),
+			WithPosition((w-20)/2, (h-3)/2, Button("This is a button", BtnParams{OnClick: func(bc *ButtonComponent) bool { return false }})),
+			WithPosition(0, h-2, Text(colors.Blue+"Navigate: Ctrl+(W/A/S/D). Click Button: Enter")),
+		),
+
+		// Page 5
+		Div(
+			WithPosition(0, 0, Text("This is a Menu. It prompts you to select a item. "+colors.Red+colors.Bold+"NOTE: This Menu is inside a div")),
+			WithPosition(0, 2, Menu("Item 1", "Item 2", "Item 3", "Item 4", "Item 5").OnSelected(func(m *MenuComponent, b bool) {})),
+			WithPosition(0, h-2, Text(colors.Blue+"Navigate: Ctrl+(W/A/S/D). Navigate Menu: W/S. Select: Enter. Exit Menu: Q. ")),
+		),
+	)
+}

isKey/key.go

@@ -0,0 +1,53 @@
+package isKey
+
+func Enter(s string) bool {
+	return s == "\r" || s == "\n"
+}
+
+func Tab(s string) bool {
+	return s == "\t"
+}
+
+func Backspace(s string) bool {
+	return s == "\x7f" || s == "\b"
+}
+
+func Escape(s string) bool {
+	return s == "\x1b"
+}
+
+func Up(s string) bool {
+	return s == "\x1b[A"
+}
+
+func Down(s string) bool {
+	return s == "\x1b[B"
+}
+
+func Right(s string) bool {
+	return s == "\x1b[C"
+}
+
+func Left(s string) bool {
+	return s == "\x1b[D"
+}
+
+func Char(s string, s1 string) bool {
+	return s == s1
+}
+
+func CtrlW(s string) bool {
+	return s == "\x17" 
+}
+
+func CtrlS(s string) bool {
+	return s == "\x13" 
+}
+
+func CtrlA(s string) bool {
+	return s == "\x01" 
+}
+
+func CtrlD(s string) bool {
+	return s == "\x04" 
+}

osui.go

@@ -2,155 +2,65 @@ package osui
 
 import (
 	"fmt"
-	"os"
 	"strings"
 
-	"golang.org/x/term"
+	"github.com/orus-dev/osui/colors"
 )
 
+type ComponentData struct {
+	X            int
+	Y            int
+	Width        int
+	Height       int
+	DefaultColor string
+	IsActive     bool
+	Screen       *Screen
+}
+
 type Component interface {
-	Render(*ComponentWrapper) string
+	Render() string
-	Run(*ComponentWrapper, ...any) any
+	GetComponentData() *ComponentData
+	Update(string) bool
+	SetStyle(interface{})
 }
 
-type ComponentWrapper struct {
+type Screen struct {
-	Component Component
+	component Component
-	X         uint16
-	Y         uint16
-	Render    *Render
-	Update    func(*ComponentWrapper, any) UpdateOutput_
-	Data      string
 }
 
-func (c *ComponentWrapper) Run(a ...any) any {
+func NewScreen(c Component) *Screen {
-	c.Render.Render()
+	HideCursor()
-	return c.Component.Run(c, a)
+	s := &Screen{component: c}
+	return s
 }
 
-func NewComponent(c Component) *ComponentWrapper {
+func (s *Screen) Render() {
-	return &ComponentWrapper{
-		Component: c,
-	}
-}
-
-type Render struct {
-	components []*ComponentWrapper
-}
-
-func NewRender() *Render {
-	return &Render{components: []*ComponentWrapper{}}
-}
-
-func (r *Render) Add(c *ComponentWrapper) *ComponentWrapper {
-	c.Render = r
-	r.components = append(r.components, c)
-	return c
-}
-
-func (r *Render) Render() error {
 	Clear()
-	width, height, err := term.GetSize(0)
+	width, height := GetTerminalSize()
-	if err != nil {
+	frame := NewFrame(width, height)
-		return fmt.Errorf("error getting the terminal size: %s", err)
+	data := s.component.GetComponentData()
-	}
+	if data.Height == 0 {
-	frame := make([]string, height)
+		data.Height = height
-	for i := 0; i < height; i++ {
-		frame[i] = strings.Repeat(" ", width)
-	}
-	for _, c := range r.components {
-		for i, line := range strings.Split(c.Component.Render(c), "\n") {
-			if int(c.Y)+i < len(frame) {
-				frame[int(c.Y)+i] = renderLine(frame[int(c.Y)+i], line, int(c.X))
-			}
 	}
+	if data.Width == 0 {
+		data.Width = width
 	}
+	data.Screen = s
+	data.IsActive = true
+	data.DefaultColor = colors.Reset
+	RenderOnFrame(s.component, &frame)
 	fmt.Print(strings.Join(frame, "\n"))
-	return nil
 }
 
-func Clear() {
+func (s *Screen) Run() {
-	fmt.Print("\x1b[H\x1b[2J\x1b[3J")
+	data := s.component.GetComponentData()
-}
+	data.Screen = s
-
+	for {
-func renderLine(frameLine, line string, x int) string {
+		s.Render()
-	result := ""
+		k, _ := ReadKey()
-	if x >= len(frameLine) {
+		if s.component.Update(k) {
-		return result
+			ShowCursor()
-	}
+			return
-
-	lChars := []rune(line)
-	for i, c := range frameLine {
-		if i >= x && len(lChars) > i-x {
-			result += string(lChars[i-x])
-		} else {
-			result += string(c)
-		}
-	}
-	return result
-}
-
-func ReadKey() (string, error) {
-	oldState, err := term.MakeRaw(int(os.Stdin.Fd()))
-	if err != nil {
-		return "", err
-	}
-	defer term.Restore(int(os.Stdin.Fd()), oldState)
-	var b [3]byte
-	n, err := os.Stdin.Read(b[:])
-	if err != nil {
-		return "", err
-	}
-	return string(b[:n]), nil
-}
-
-func KeyUpdate(keys map[string]UpdateOutput_) func(c *ComponentWrapper, key any) UpdateOutput_ {
-	return func(c *ComponentWrapper, k any) UpdateOutput_ {
-		action, ok := keys[fmt.Sprint(k)]
-		if ok {
-			return action
-		} else {
-			return UpdateOutput.Continue
 		}
 	}
 }
-
-type UpdateOutput_ = int
-
-type updateOutput struct {
-	/*Continue the default check*/
-	Continue UpdateOutput_
-	/*Jump to the next check*/
-	Jmp UpdateOutput_
-	/*Leave the loop and stop the function*/
-	Exit UpdateOutput_
-}
-
-var UpdateOutput = updateOutput{Continue: 0, Jmp: 1, Exit: 2}
-
-/*
-Keys
-*/
-
-type Key_ = string
-
-type key struct {
-	Enter     Key_
-	Tab       Key_
-	Backspace Key_
-	Escape    Key_
-	Up        Key_
-	Down      Key_
-	Right     Key_
-	Left      Key_
-}
-
-var Key = key{
-	Enter:     "\r",
-	Tab:       "\t",
-	Backspace: "\x7f",
-	Escape:    "\x1b",
-	Up:        "\x1b[A",
-	Down:      "\x1b[B",
-	Right:     "\x1b[C",
-	Left:      "\x1b[D",
-}

ui/README.md

@@ -0,0 +1,37 @@
+# Component template (use rename symbol)
+
+```go
+type HelloStyle struct {
+	Fg string `defaults:"" type:"fg"`
+}
+
+type HelloComponent struct {
+	Data  osui.ComponentData
+	Style *HelloStyle
+	Name  string
+}
+
+func (h *HelloComponent) GetComponentData() *osui.ComponentData {
+	return &h.Data
+}
+
+func (h *HelloComponent) Render() string {
+	osui.UseStyle(h.Style)
+	return "Hello " + h.Style.Fg + h.Name + colors.Reset + "!"
+}
+
+func (h *HelloComponent) Update(key string) bool {
+	return false
+}
+
+func (h *HelloComponent) SetStyle(c interface{}) {
+	h.Style = osui.SetDefaults(c.(*HelloStyle)).(*HelloStyle)
+}
+
+func Hello(name string) *HelloComponent {
+	return osui.NewComponent(&HelloComponent{
+		Name:  name,
+		Style: osui.SetDefaults(&HelloStyle{}).(*HelloStyle),
+	}).(*HelloComponent)
+}
+```

ui/button.go

@@ -0,0 +1,119 @@
+package ui
+
+import (
+	"fmt"
+	"strings"
+	"time"
+
+	"github.com/orus-dev/osui"
+	"github.com/orus-dev/osui/colors"
+	"github.com/orus-dev/osui/isKey"
+)
+
+type ButtonStyle struct {
+	Background string `default:"" type:"bg"`
+	Foreground string `default:"" type:"fg"`
+	Outline    string `default:"" type:"fg"`
+
+	ActiveBackground string `default:"" type:"bg"`
+	ActiveForeground string `default:"\x1b[34m" type:"fg"`
+	ActiveOutline    string `default:"" type:"fg"`
+
+	ClickedBackground string `default:"" type:"bg"`
+	ClickedForeground string `default:"\x1b[32m" type:"fg"`
+	ClickedOutline    string `default:"" type:"fg"`
+}
+
+type ButtonComponent struct {
+	Data    osui.ComponentData
+	Style   *ButtonStyle
+	Text    string
+	Toggle  bool
+	Clicked bool
+	OnClick func(*ButtonComponent) bool
+}
+
+func (b *ButtonComponent) Render() string {
+	osui.UseStyle(b.Style)
+
+	if b.Clicked {
+		return fmt.Sprintf(" %s\n%s│%s│%s\n %s",
+			colors.Reset+b.Style.ClickedOutline+strings.Repeat("_", b.Data.Width)+colors.Reset+b.Data.DefaultColor,
+			colors.Reset+b.Style.ClickedOutline,
+			colors.Reset+colors.Combine(b.Style.ClickedBackground, b.Style.ClickedForeground)+centerText(b.Text, b.Data.Width)+colors.Reset+b.Style.ClickedOutline,
+			colors.Reset+b.Data.DefaultColor,
+			colors.Reset+b.Style.ClickedOutline+strings.Repeat("‾", b.Data.Width)+colors.Reset+b.Data.DefaultColor,
+		)
+	}
+
+	if b.Data.IsActive {
+		return fmt.Sprintf(" %s\n%s│%s│%s\n %s",
+			colors.Reset+b.Style.ActiveOutline+strings.Repeat("_", b.Data.Width)+colors.Reset+b.Data.DefaultColor,
+			colors.Reset+b.Style.ActiveOutline,
+			colors.Reset+colors.Combine(b.Style.ActiveBackground, b.Style.ActiveForeground)+centerText(b.Text, b.Data.Width)+colors.Reset+b.Style.ActiveOutline,
+			colors.Reset+b.Data.DefaultColor,
+			colors.Reset+b.Style.ActiveOutline+strings.Repeat("‾", b.Data.Width)+colors.Reset+b.Data.DefaultColor,
+		)
+	}
+
+	return fmt.Sprintf(" %s\n%s│%s│%s\n %s",
+		colors.Reset+b.Style.Outline+strings.Repeat("_", b.Data.Width)+colors.Reset+b.Data.DefaultColor,
+		colors.Reset+b.Style.Outline,
+		colors.Reset+colors.Combine(b.Style.Background, b.Style.Foreground)+centerText(b.Text, b.Data.Width)+colors.Reset+b.Style.Outline,
+		colors.Reset+b.Data.DefaultColor,
+		colors.Reset+b.Style.Outline+strings.Repeat("‾", b.Data.Width)+colors.Reset+b.Data.DefaultColor,
+	)
+}
+
+func (b *ButtonComponent) Update(key string) bool {
+	if isKey.Enter(key) {
+		if !b.OnClick(b) {
+			if b.Toggle {
+				b.Clicked = !b.Clicked
+				return false
+			}
+			b.Clicked = true
+			b.Data.Screen.Render()
+			time.Sleep(time.Millisecond * 120)
+			b.Clicked = false
+		}
+	}
+	return false
+}
+
+func (b *ButtonComponent) GetComponentData() *osui.ComponentData {
+	return &b.Data
+}
+
+func (b *ButtonComponent) SetStyle(style interface{}) {
+	b.Style = osui.SetDefaults(style).(*ButtonStyle)
+}
+
+type BtnParams struct {
+	Style   ButtonStyle
+	Toggle  bool
+	OnClick func(*ButtonComponent) bool
+	Width   int
+}
+
+func Button(text string, p ...BtnParams) *ButtonComponent {
+	if len(p) > 0 {
+		param := p[0]
+		return &ButtonComponent{Text: text, Style: osui.SetDefaults(&param.Style).(*ButtonStyle),
+			Data: osui.ComponentData{
+				Width:  osui.LogicValueInt(param.Width == 0, 20, param.Width),
+				Height: 1,
+			},
+			OnClick: fnLogicValue(param.OnClick),
+		}
+
+	}
+	return &ButtonComponent{Text: text,
+		Style: osui.SetDefaults(&ButtonStyle{}).(*ButtonStyle),
+		Data: osui.ComponentData{
+			Width:  20,
+			Height: 1,
+		},
+		OnClick: func(bc *ButtonComponent) bool { return false },
+	}
+}

ui/components.go

@@ -1,70 +0,0 @@
-package ui
-
-import (
-	"fmt"
-	"strings"
-
-	"github.com/orus-dev/osui"
-)
-
-type ComponentText struct{ Text string }
-
-func (t ComponentText) Render(cw *osui.ComponentWrapper) string {
-	return t.Text
-}
-
-func (t ComponentText) Run(cw *osui.ComponentWrapper, a ...any) any {
-	return nil
-}
-
-type ComponentInputBox struct {
-	max_size uint
-}
-
-func (s ComponentInputBox) Render(cw *osui.ComponentWrapper) string {
-	return fmt.Sprintf(
-		" %s\n|%s%s|\n %s",
-		strings.Repeat("_", int(s.max_size)),
-		cw.Data,
-		strings.Repeat(" ", int(s.max_size)-len(cw.Data)),
-		strings.Repeat("‾", int(s.max_size)),
-	)
-}
-
-func (s ComponentInputBox) Run(cw *osui.ComponentWrapper, a ...any) any {
-	for {
-		fmt.Printf("\x1B[%d;%dH", cw.Y+2, int(cw.X+2)+len(cw.Data))
-		key, err := osui.ReadKey()
-		if err != nil {
-			fmt.Println(err)
-			break
-		}
-		switch cw.Update(cw, key) {
-
-		case osui.UpdateOutput.Jmp:
-			continue
-		case osui.UpdateOutput.Exit:
-			fmt.Print("\n\n")
-			return cw.Data
-
-		}
-		switch key {
-
-		case osui.Key.Enter:
-			fmt.Print("\n\n")
-			return cw.Data
-
-		case osui.Key.Backspace:
-			if len(cw.Data) > 0 {
-				cw.Data = cw.Data[:len(cw.Data)-1]
-			}
-
-		default:
-			if int(s.max_size) > len(cw.Data) {
-				cw.Data += key
-			}
-		}
-		cw.Render.Render()
-	}
-	return cw.Data
-}

ui/div.go

@@ -0,0 +1,105 @@
+package ui
+
+import (
+	"strings"
+
+	"github.com/orus-dev/osui"
+	"github.com/orus-dev/osui/colors"
+	"github.com/orus-dev/osui/isKey"
+)
+
+type DivStyle struct {
+	Background string `default:"" type:"bg"`
+	Foreground string `default:"" type:"fg"`
+	Outline    string `default:"" type:"fg"`
+}
+
+type DivComponent struct {
+	Data            osui.ComponentData
+	Style           *DivStyle
+	Components      []osui.Component
+	ActiveComponent int
+}
+
+func (d *DivComponent) GetComponentData() *osui.ComponentData {
+	return &d.Data
+}
+
+func (d *DivComponent) Render() string {
+	osui.UseStyle(d.Style)
+	frame := osui.NewFrame(d.Data.Width, d.Data.Height)
+	for i, c := range d.Components {
+		data := c.GetComponentData()
+		if i == d.ActiveComponent {
+			data.IsActive = d.Data.IsActive
+		} else {
+			data.IsActive = false
+		}
+		if data.Width == 0 {
+			data.Width = d.Data.Width
+		}
+		if data.Height == 0 {
+			data.Height = d.Data.Height
+		}
+		data.DefaultColor = colors.Combine(d.Style.Background, d.Style.Foreground)
+		data.Screen = d.Data.Screen
+		osui.RenderOnFrame(c, &frame)
+	}
+	if d.Style.Outline == "" {
+		for i, f := range frame {
+			frame[i] = colors.Combine(d.Style.Foreground, d.Style.Background) + f + colors.Reset
+		}
+		return strings.Join(frame, "\n")
+	} else {
+		for i, f := range frame {
+			frame[i] = d.Style.Outline + "│" + colors.Combine(d.Style.Foreground, d.Style.Background) + f + colors.Reset + d.Style.Outline + "│" + colors.Reset
+		}
+	}
+	return " " + d.Style.Outline + strings.Repeat("_", d.Data.Width) + colors.Reset + "\n" + strings.Join(frame, "\n") + "\n " + d.Style.Outline + strings.Repeat("‾", d.Data.Width) + colors.Reset
+}
+
+func (d *DivComponent) Update(key string) bool {
+	if isKey.CtrlW(key) {
+		d.updateActive(findClosestComponent(d.Components, d.ActiveComponent, "up"))
+	} else if isKey.CtrlS(key) {
+		d.updateActive(findClosestComponent(d.Components, d.ActiveComponent, "down"))
+	} else if isKey.CtrlA(key) {
+		d.updateActive(findClosestComponent(d.Components, d.ActiveComponent, "left"))
+	} else if isKey.CtrlD(key) {
+		d.updateActive(findClosestComponent(d.Components, d.ActiveComponent, "right"))
+	} else {
+		if len(d.Components) > 0 {
+			d.Components[d.ActiveComponent].GetComponentData().IsActive = d.Data.IsActive
+			if d.Components[d.ActiveComponent].Update(key) {
+				if d.ActiveComponent < len(d.Components)-1 {
+					d.updateActive(d.ActiveComponent + 1)
+				} else {
+					return true
+				}
+			}
+		}
+	}
+	return false
+}
+
+func (d *DivComponent) SetStyle(c interface{}) {
+	d.Style = osui.SetDefaults(c.(*DivStyle)).(*DivStyle)
+}
+
+func (d *DivComponent) updateActive(newIndex int) {
+	if newIndex >= 0 && newIndex < len(d.Components) && len(d.Components) > 0 {
+		d.ActiveComponent = newIndex
+	}
+}
+
+func (d *DivComponent) AddTo(c *DivComponent) *DivComponent {
+	*c = *d
+	return d
+}
+
+func Div(components ...osui.Component) *DivComponent {
+	return &DivComponent{
+		Components: components,
+		Style:      osui.SetDefaults(&DivStyle{}).(*DivStyle),
+	}
+}

ui/inputBox.go

@@ -0,0 +1,86 @@
+package ui
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/orus-dev/osui"
+	"github.com/orus-dev/osui/colors"
+	"github.com/orus-dev/osui/isKey"
+)
+
+type InputBoxStyle struct {
+	Background string `default:"" type:"bg"`
+	Foreground string `default:"" type:"fg"`
+	Outline    string `default:"" type:"fg"`
+	Cursor     string `default:"" type:"fg"`
+}
+
+type InputBoxComponent struct {
+	Data      osui.ComponentData
+	Style     *InputBoxStyle
+	max_size  uint
+	cursor    uint
+	InputData string
+}
+
+func (s *InputBoxComponent) GetComponentData() *osui.ComponentData {
+	return &s.Data
+}
+
+func (s InputBoxComponent) Render() string {
+	osui.UseStyle(s.Style)
+	if s.max_size > uint(len(s.InputData)) {
+		return fmt.Sprintf(
+			" %s\n%s│%s%s│%s\n %s",
+			colors.Reset+s.Style.Outline+strings.Repeat("_", int(s.max_size))+colors.Reset,
+			colors.Reset+s.Style.Outline,
+			colors.Combine(s.Style.Foreground, s.Style.Background)+s.InputData+osui.LogicValue(s.Data.IsActive, s.Style.Cursor+"█"+colors.Combine(s.Style.Foreground, s.Style.Background), ""),
+			strings.Repeat(" ", int(s.max_size)-len(s.InputData)-osui.LogicValueInt(s.Data.IsActive, 1, 0))+colors.Reset+s.Style.Outline,
+			colors.Reset+s.Data.DefaultColor,
+			s.Style.Outline+strings.Repeat("‾", int(s.max_size))+colors.Reset+s.Data.DefaultColor,
+		)
+	}
+
+	return fmt.Sprintf(
+		" %s\n%s│%s%s\n %s",
+		colors.Reset+s.Style.Outline+strings.Repeat("_", int(s.max_size))+colors.Reset,
+		colors.Reset+s.Style.Outline,
+		colors.Combine(s.Style.Foreground, s.Style.Background)+s.InputData+osui.LogicValue(s.Data.IsActive, s.Style.Cursor+"█"+colors.Reset, s.Style.Outline+"|"+colors.Reset),
+		colors.Reset+s.Data.DefaultColor,
+		colors.Reset+s.Style.Outline+strings.Repeat("‾", int(s.max_size))+colors.Reset+s.Data.DefaultColor,
+	)
+}
+
+func (s *InputBoxComponent) Update(key string) bool {
+	if isKey.Enter(key) {
+		return true
+	} else if isKey.Backspace(key) {
+		if len(s.InputData) > 0 {
+			s.InputData = s.InputData[:len(s.InputData)-1]
+		}
+	} else if isKey.Left(key) {
+		if s.cursor > 0 {
+			s.cursor--
+		}
+	} else if isKey.Right(key) {
+		if s.cursor < s.max_size {
+			s.cursor++
+		}
+	} else {
+		if len(key) == 1 {
+			if int(s.max_size) > len(s.InputData) {
+				s.InputData += key
+			}
+		}
+	}
+	return false
+}
+
+func (d *InputBoxComponent) SetStyle(c interface{}) {
+	d.Style = osui.SetDefaults(c.(*InputBoxStyle)).(*InputBoxStyle)
+}
+
+func InputBox(max_size uint) *InputBoxComponent {
+	return &InputBoxComponent{max_size: max_size, Style: osui.SetDefaults(&InputBoxStyle{}).(*InputBoxStyle)}
+}

ui/menu.go

@@ -0,0 +1,91 @@
+package ui
+
+import (
+	"strings"
+
+	"github.com/orus-dev/osui"
+	"github.com/orus-dev/osui/colors"
+	"github.com/orus-dev/osui/isKey"
+)
+
+type MenuStyle struct {
+	Fg             string `default:"" type:"fg"`
+	Bg             string `default:"" type:"bg"`
+	SelectedFg     string `default:"\x1b[34m" type:"fg"`
+	SelectedBg     string `default:"" type:"bg"`
+	Cursor         string `default:"> " type:"fg"`
+	CursorInactive string `default:"  " type:"fg"`
+}
+
+type MenuComponent struct {
+	Data         osui.ComponentData
+	Style        *MenuStyle
+	Items        []string
+	SelectedItem int
+	onSelected   func(*MenuComponent, bool)
+}
+
+func (m *MenuComponent) GetComponentData() *osui.ComponentData {
+	return &m.Data
+}
+
+func (m *MenuComponent) Render() string {
+	osui.UseStyle(m.Style)
+	res := []string{}
+
+	cursor := m.Style.Cursor
+	if !m.Data.IsActive {
+		cursor = m.Style.CursorInactive
+	}
+	d, _ := osui.CompressString(m.Style.Cursor, "")
+	empty := strings.Repeat(" ", len(d))
+
+	for i, item := range m.Items {
+		if i == m.SelectedItem {
+			res = append(res, cursor+colors.Combine(m.Style.SelectedFg, m.Style.SelectedBg)+item+colors.Reset+m.Data.DefaultColor)
+		} else {
+			res = append(res, empty+colors.Combine(m.Style.Fg, m.Style.Bg)+item+colors.Reset+m.Data.DefaultColor)
+		}
+	}
+
+	return strings.Join(res, "\n")
+}
+
+func (m *MenuComponent) Update(key string) bool {
+	if isKey.Char(key, "s") {
+		if m.SelectedItem+1 < len(m.Items) {
+			m.SelectedItem++
+		} else {
+			m.SelectedItem = 0
+		}
+	} else if isKey.Char(key, "w") {
+		if m.SelectedItem > 0 {
+			m.SelectedItem--
+		} else {
+			m.SelectedItem = len(m.Items) - 1
+		}
+	} else if isKey.Enter(key) {
+		m.onSelected(m, true)
+		return true
+	} else if isKey.Char(key, "q") {
+		m.onSelected(m, false)
+		return true
+	}
+	return false
+}
+
+func (m *MenuComponent) SetStyle(c interface{}) {
+	m.Style = osui.SetDefaults(c.(*MenuStyle)).(*MenuStyle)
+}
+
+func (m *MenuComponent) OnSelected(f func(*MenuComponent, bool)) *MenuComponent {
+	m.onSelected = f
+	return m
+}
+
+func Menu(items ...string) *MenuComponent {
+	return &MenuComponent{
+		Items: items,
+		Style: osui.SetDefaults(&MenuStyle{}).(*MenuStyle),
+	}
+}

ui/paginator.go

@@ -0,0 +1,104 @@
+package ui
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/orus-dev/osui"
+	"github.com/orus-dev/osui/colors"
+	"github.com/orus-dev/osui/isKey"
+)
+
+type PaginatorStyle struct {
+	Active   string `default:"\033[32m"`
+	Inactive string `default:""`
+}
+
+type PaginatorComponent struct {
+	Data            osui.ComponentData
+	Style           *PaginatorStyle
+	Components      []osui.Component
+	ActiveComponent int
+}
+
+func (p *PaginatorComponent) GetComponentData() *osui.ComponentData {
+	return &p.Data
+}
+
+func (p *PaginatorComponent) Render() string {
+	width, _ := osui.GetTerminalSize()
+	pgs := strings.Repeat(" ", (width-len(p.Components))/2)
+	osui.UseStyle(p.Style)
+	frame := osui.NewFrame(p.Data.Width, p.Data.Height)
+	for i, c := range p.Components {
+		data := c.GetComponentData()
+		if i == p.ActiveComponent {
+			pgs += p.Style.Active + "•" + colors.Reset
+			data.IsActive = true
+		} else {
+			pgs += colors.Reset + p.Style.Inactive + "•"
+			data.IsActive = false
+		}
+		if data.Width == 0 {
+			data.Width = p.Data.Width
+		}
+		if data.Height == 0 {
+			data.Height = p.Data.Height
+		}
+		data.DefaultColor = p.Data.DefaultColor
+		data.Screen = p.Data.Screen
+	}
+	osui.RenderOnFrame(p.Components[p.ActiveComponent], &frame)
+	for i, f := range frame {
+		frame[i] = colors.Reset + p.Data.DefaultColor + f + colors.Reset
+	}
+	return fmt.Sprintf("%s\n%s", pgs, colors.Reset+strings.Join(frame, "\n"))
+}
+
+func (p *PaginatorComponent) Update(key string) bool {
+	if key == "\x1b[Z" {
+		if p.ActiveComponent > 0 {
+			p.updateActive(p.ActiveComponent - 1)
+		} else {
+			p.updateActive(len(p.Components) - 1)
+		}
+	} else if isKey.Tab(key) {
+		if p.ActiveComponent < len(p.Components)-1 {
+			p.updateActive(p.ActiveComponent + 1)
+		} else {
+			p.updateActive(0)
+		}
+	} else if isKey.Escape(key) {
+		fmt.Print("\n\n")
+		return true
+	} else {
+		if len(p.Components) > 0 {
+			p.Components[p.ActiveComponent].GetComponentData().IsActive = p.Data.IsActive
+			if p.Components[p.ActiveComponent].Update(key) {
+				if p.ActiveComponent < len(p.Components)-1 {
+					p.updateActive(p.ActiveComponent + 1)
+				} else {
+					p.updateActive(0)
+				}
+			}
+		}
+	}
+	return false
+}
+
+func (p *PaginatorComponent) updateActive(newIndex int) {
+	if newIndex >= 0 && newIndex < len(p.Components) && len(p.Components) > 0 {
+		p.ActiveComponent = newIndex
+	}
+}
+
+func (p *PaginatorComponent) SetStyle(c interface{}) {
+	p.Style = osui.SetDefaults(c.(*PaginatorStyle)).(*PaginatorStyle)
+}
+
+func Paginator(pages ...osui.Component) *PaginatorComponent {
+	return &PaginatorComponent{
+		Components: pages,
+		Style:      osui.SetDefaults(&PaginatorStyle{}).(*PaginatorStyle),
+	}
+}

ui/text.go

@@ -0,0 +1,28 @@
+package ui
+
+import (
+	"github.com/orus-dev/osui"
+)
+
+type TextComponent struct {
+	Data osui.ComponentData
+	Text string
+}
+
+func (t *TextComponent) Update(string) bool {
+	return false
+}
+
+func (t *TextComponent) GetComponentData() *osui.ComponentData {
+	return &t.Data
+}
+
+func (t TextComponent) Render() string {
+	return t.Text
+}
+
+func (t *TextComponent) SetStyle(interface{}) {}
+
+func Text(text string) *TextComponent {
+	return &TextComponent{Text: text}
+}

ui/ui.go

@@ -1,13 +0,0 @@
-package ui
-
-import (
-	"github.com/orus-dev/osui"
-)
-
-func InputBox(max_size uint) *osui.ComponentWrapper {
-	return osui.NewComponent(ComponentInputBox{max_size: max_size})
-}
-
-func Text(text string) *osui.ComponentWrapper {
-	return osui.NewComponent(ComponentText{Text: text})
-}

ui/utils.go

@@ -0,0 +1,96 @@
+package ui
+
+import (
+	"fmt"
+	"math"
+	"strings"
+
+	"github.com/orus-dev/osui"
+)
+
+func centerText(text string, width int) string {
+	if len(text) > width {
+		return text[:width]
+	}
+	padding := (width - len(text)) / 2
+	leftPadding := strings.Repeat(" ", padding)
+	rightPadding := strings.Repeat(" ", padding)
+
+	return fmt.Sprintf("%s%s%s", leftPadding, text, rightPadding)
+}
+
+func fnLogicValue(f func(*ButtonComponent) bool) func(*ButtonComponent) bool {
+	if f == nil {
+		return func(*ButtonComponent) bool { return false }
+	} else {
+		return f
+	}
+}
+
+func WithPosition(x, y int, c osui.Component) osui.Component {
+	data := c.GetComponentData()
+	data.X = x
+	data.Y = y
+	return c
+}
+
+func WithStyle(style interface{}, c osui.Component) osui.Component {
+	c.SetStyle(style)
+	return c
+}
+
+func WithSize(width, height int, c osui.Component) osui.Component {
+	data := c.GetComponentData()
+	data.Width = width
+	data.Height = height
+	return c
+}
+
+func findClosestComponent(a []osui.Component, i int, d string) int {
+	if len(a) == 0 || i < 0 || i >= len(a) {
+		return -1 // Invalid input
+	}
+
+	current := a[i].GetComponentData()
+	closestIndex := -1
+	minDistance := math.MaxFloat64
+
+	for j, c := range a {
+		component := c.GetComponentData()
+		if i == j {
+			continue // Skip the current component
+		}
+
+		// Check if the component is in the correct direction
+		isValidDirection := false
+		switch d {
+		case "up":
+			if component.Y < current.Y {
+				isValidDirection = true
+			}
+		case "down":
+			if component.Y > current.Y {
+				isValidDirection = true
+			}
+		case "left":
+			if component.X < current.X {
+				isValidDirection = true
+			}
+		case "right":
+			if component.X > current.X {
+				isValidDirection = true
+			}
+		}
+
+		// If the direction is valid, calculate distance
+		if isValidDirection {
+			distance := math.Hypot(float64(component.X-current.X), float64(component.Y-current.Y))
+			if distance < minDistance {
+				minDistance = distance
+				closestIndex = j
+			}
+		}
+	}
+
+	return closestIndex
+}

utils.go

@@ -0,0 +1,182 @@
+package osui
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"reflect"
+	"regexp"
+	"runtime"
+	"strings"
+
+	"github.com/orus-dev/osui/colors"
+	"golang.org/x/term"
+)
+
+func renderLine(frameLine, line_ string, x int) string {
+	frame := []rune(frameLine)
+	line := []rune(line_)
+
+	i := 0
+	v := 0
+	for j, c := range frame {
+		if i+j >= x && v < len(line) {
+			if c != '\b' && line[v] == '\t' {
+				frame = append(frame[:i+j], append([]rune{' '}, frame[i+j:]...)...)
+			}
+			frame[i+j] = line[v]
+			v++
+		}
+		if c == '\b' {
+			i++
+		}
+	}
+
+	return string(frame)
+}
+
+func RenderOnFrame(c Component, frame *[]string) {
+	componentData := c.GetComponentData()
+	for i, lo := range strings.Split(c.Render(), "\n") {
+		if int(componentData.Y)+i < len(*frame) {
+			fo := (*frame)[int(componentData.Y)+i]
+			f, fa := CompressString(fo, "\b")
+			line, la := CompressString(lo, "\t")
+			r := renderLine(f, line, int(componentData.X))
+			(*frame)[int(componentData.Y)+i] = DecompressString(DecompressString(r, la, "\t"), fa, "\b")
+		}
+	}
+}
+
+func CompressString(input, repl string) (string, []string) {
+	pattern := `\x1b\[([0-9;]*)[a-zA-Z]`
+	re := regexp.MustCompile(pattern)
+	matches := re.FindAllString(input, -1)
+	return re.ReplaceAllString(input, repl), matches
+}
+
+func DecompressString(modified string, outputArray []string, c string) string {
+	parts := strings.Split(modified, c)
+	reconstructed := ""
+	for i, part := range parts {
+		reconstructed += part
+		if i < len(outputArray) {
+			reconstructed += outputArray[i]
+		}
+	}
+	return reconstructed
+}
+
+func ReadKey() (string, error) {
+	oldState, err := term.MakeRaw(int(os.Stdin.Fd()))
+	if err != nil {
+		return "", err
+	}
+	defer term.Restore(int(os.Stdin.Fd()), oldState)
+	var b [3]byte
+	n, err := os.Stdin.Read(b[:])
+	if err != nil {
+		return "", err
+	}
+	return string(b[:n]), nil
+}
+
+func NewFrame(width, height int) []string {
+	frame := make([]string, height)
+	for i := 0; i < height; i++ {
+		frame[i] = strings.Repeat(" ", width)
+	}
+	return frame
+}
+
+func Clear() {
+	switch runtime.GOOS {
+	case "windows":
+		cmd := exec.Command("cmd", "/c", "cls")
+		cmd.Stdout = os.Stdout
+		cmd.Run()
+	default:
+		cmd := exec.Command("clear")
+		cmd.Stdout = os.Stdout
+		cmd.Run()
+	}
+}
+
+func SetDefaults(p interface{}) interface{} {
+	v := reflect.ValueOf(p)
+	if v.Kind() != reflect.Ptr {
+		panic("SetDefaults: expected a pointer to a struct")
+	}
+	val := v.Elem()
+	if val.Kind() != reflect.Struct {
+		panic("SetDefaults: expected a pointer to a struct")
+	}
+	typ := val.Type()
+	for i := 0; i < val.NumField(); i++ {
+		field := val.Field(i)
+		structField := typ.Field(i)
+		if defaultValue, ok := structField.Tag.Lookup("default"); ok {
+			if field.Kind() == reflect.String && field.String() == "" {
+				field.SetString(defaultValue)
+			}
+		}
+	}
+	return p
+}
+
+func UseStyle(p interface{}) {
+	SetDefaults(p)
+	v := reflect.ValueOf(p)
+	if v.Kind() != reflect.Ptr {
+		panic("SetStyle: expected a pointer to a struct")
+	}
+	val := v.Elem()
+	if val.Kind() != reflect.Struct {
+		panic("SetStyle: expected a pointer to a struct")
+	}
+	typ := val.Type()
+	for i := 0; i < val.NumField(); i++ {
+		field := val.Field(i)
+		structField := typ.Field(i)
+		if styleType, ok := structField.Tag.Lookup("type"); ok {
+			if field.Kind() == reflect.String {
+				if styleType == "bg" || styleType == "background" {
+					field.SetString(colors.AsBg(field.String()))
+				} else {
+					field.SetString(colors.AsFg(field.String()))
+				}
+			}
+		}
+	}
+
+}
+
+func ShowCursor() {
+	fmt.Print("\033[?25h")
+}
+
+func HideCursor() {
+	fmt.Print("\033[?25l")
+}
+
+func LogicValue(b bool, _if, _else string) string {
+	if b {
+		return _if
+	}
+	return _else
+}
+
+func LogicValueInt(b bool, _if, _else int) int {
+	if b {
+		return _if
+	}
+	return _else
+}
+
+func GetTerminalSize() (int, int) {
+	w, h, err := term.GetSize(0)
+	if err != nil {
+		panic(err)
+	}
+	return w, h
+}