docs(tutorials): update tutorials

Author: aymanbagabas

tutorials/basics/README.md

@@ -1,7 +1,7 @@
 # Bubble Tea Basics
 
 Bubble Tea is based on the functional design paradigms of [The Elm
-Architecture][elm], which happens to work nicely with Go. It's a delightful way
+Architecture][elm], which happens to work nicely with Go. It’s a delightful way
 to build applications.
 
 This tutorial assumes you have a working knowledge of Go.
@@ -12,12 +12,12 @@ By the way, the non-annotated source code for this program is available
 [elm]: https://guide.elm-lang.org/architecture/
 [tut-source]: https://github.com/charmbracelet/bubbletea/tree/master/tutorials/basics
 
-## Enough! Let's get to it.
+## Enough! Let’s get to it.
 
-For this tutorial, we're making a shopping list.
+For this tutorial, we’re making a shopping list.
 
-To start we'll define our package and import some libraries. Our only external
-import will be the Bubble Tea library, which we'll call `tea` for short.
+To start we’ll define our package and import some libraries. Our only external
+import will be the Bubble Tea library, which we’ll call `tea` for short.
 
 ```go
 package main
@@ -26,7 +26,7 @@ import (
     "fmt"
     "os"
 
-    tea "github.com/charmbracelet/bubbletea/v2"
+    tea "charm.land/bubbletea/v2"
 )
 ```
 
@@ -39,7 +39,7 @@ state and three simple methods on that model:
 
 ## The Model
 
-So let's start by defining our model which will store our application's state.
+So let’s start by defining our model which will store our application’s state.
 It can be any type, but a `struct` usually makes the most sense.
 
 ```go
@@ -70,34 +70,22 @@ func initialModel() model {
 }
 ```
 
-After that, we’ll define our application’s initial state in the `Init` method. `Init`
-can return a `Cmd` that could perform some initial I/O. For now, we don't need
-to do any I/O, so for the command, we'll just return `nil`, which translates to
-"no command."
+After that, we’ll define the `Init` method. `Init` can return a `Cmd` that
+could perform some initial I/O. For now, we don’t need to do any I/O, so for
+the command, we’ll just return `nil`, which translates to "no command."
 
 ```go
-func (m model) Init() (tea.Model, tea.Cmd) {
-	m = {
-		// Our to-do list is a grocery list
-		choices:  []string{"Buy carrots", "Buy celery", "Buy kohlrabi"},
-
-		// A map which indicates which choices are selected. We're using
-		// the map like a mathematical set. The keys refer to the indexes
-		// of the `choices` slice, above.
-		selected: make(map[int]struct{}),
-	}
-
-    // Just return `nil`, which means "no I/O right now, please."
-    return m, nil
+func (m model) Init() tea.Cmd {
+    return nil
 }
 ```
 
 ## The Update Method
 
-Next up is the update method. The update function is called when ”things
+Next up is the update method. The update function is called when “things
 happen.” Its job is to look at what has happened and return an updated model in
 response. It can also return a `Cmd` to make more things happen, but for now
-don't worry about that part.
+don’t worry about that part.
 
 In our case, when a user presses the down arrow, `Update`’s job is to notice
 that the down arrow was pressed and move the cursor accordingly (or not).
@@ -109,7 +97,7 @@ tick, or a response from a server.
 We usually figure out which type of `Msg` we received with a type switch, but
 you could also use a type assertion.
 
-For now, we'll just deal with `tea.KeyPressMsg` messages, which are
+For now, we’ll just deal with `tea.KeyPressMsg` messages, which are
 automatically sent to the update function when keys are pressed.
 
 ```go
@@ -164,14 +152,15 @@ the Bubble Tea runtime to quit, exiting the program.
 
 At last, it’s time to render our UI. Of all the methods, the view is the
 simplest. We look at the model in its current state and use it to return
-a `string`. That string is our UI!
+a `tea.View`. The view declares our UI content and, optionally, terminal
+features like alt screen mode, mouse tracking, cursor position, and more.
 
 Because the view describes the entire UI of your application, you don’t have to
 worry about redrawing logic and stuff like that. Bubble Tea takes care of it
 for you.
 
 ```go
-func (m model) View() string {
+func (m model) View() tea.View {
     // The header
     s := "What should we buy at the market?\n\n"
 
@@ -198,13 +187,13 @@ func (m model) View() string {
     s += "\nPress q to quit.\n"
 
     // Send the UI for rendering
-    return s
+    return tea.NewView(s)
 }
 ```
 
 ## All Together Now
 
-The last step is to simply run our program. We pass an empty model
+The last step is to simply run our program. We pass our initial model to
 `tea.NewProgram` and let it rip:
 
 ```go
@@ -220,15 +209,15 @@ func main() {
 ## What’s Next?
 
 This tutorial covers the basics of building an interactive terminal UI, but
-in the real world you'll also need to perform I/O. To learn about that have a
-look at the [Command Tutorial][cmd]. It's pretty simple.
+in the real world you’ll also need to perform I/O. To learn about that have a
+look at the [Command Tutorial][cmd]. It’s pretty simple.
 
 There are also several [Bubble Tea examples][examples] available and, of course,
 there are [Go Docs][docs].
 
 [cmd]: http://github.com/charmbracelet/bubbletea/tree/master/tutorials/commands/
 [examples]: http://github.com/charmbracelet/bubbletea/tree/master/examples
-[docs]: https://pkg.go.dev/github.com/charmbracelet/bubbletea?tab=doc
+[docs]: https://pkg.go.dev/charm.land/bubbletea/v2?tab=doc
 
 ## Additional Resources
 
@@ -237,7 +226,7 @@ there are [Go Docs][docs].
 
 ### Feedback
 
-We'd love to hear your thoughts on this tutorial. Feel free to drop us a note!
+We’d love to hear your thoughts on this tutorial. Feel free to drop us a note!
 
 - [Twitter](https://twitter.com/charmcli)
 - [The Fediverse](https://mastodon.social/@charmcli)

tutorials/basics/main.go

@@ -4,7 +4,7 @@ import (
 	"fmt"
 	"os"
 
-	tea "github.com/charmbracelet/bubbletea/v2"
+	tea "charm.land/bubbletea/v2"
 )
 
 type model struct {
@@ -26,7 +26,7 @@ func initialModel() model {
 }
 
 func (m model) Init() tea.Cmd {
-	return tea.SetWindowTitle("Grocery List")
+	return nil
 }
 
 func (m model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
@@ -56,7 +56,7 @@ func (m model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 	return m, nil
 }
 
-func (m model) View() string {
+func (m model) View() tea.View {
 	s := "What should we buy at the market?\n\n"
 
 	for i, choice := range m.choices {
@@ -75,7 +75,10 @@ func (m model) View() string {
 
 	s += "\nPress q to quit.\n"
 
-	return s
+	v := tea.NewView(s)
+	v.WindowTitle = "Grocery List"
+
+	return v
 }
 
 func main() {

tutorials/commands/README.md

@@ -9,12 +9,12 @@ You can find the non-annotated version of this program [on GitHub][source].
 [basics]: https://github.com/charmbracelet/bubbletea/tree/master/tutorials/basics
 [source]: https://github.com/charmbracelet/bubbletea/blob/master/tutorials/commands/main.go
 
-## Let's Go!
+## Let’s Go!
 
-For this tutorial we're building a very simple program that makes an HTTP
+For this tutorial we’re building a very simple program that makes an HTTP
 request to a server and reports the status code of the response.
 
-We'll import a few necessary packages and put the URL we're going to check in
+We’ll import a few necessary packages and put the URL we’re going to check in
 a `const`.
 
 ```go
@@ -26,15 +26,15 @@ import (
     "os"
     "time"
 
-    tea "github.com/charmbracelet/bubbletea/v2"
+    tea "charm.land/bubbletea/v2"
 )
 
 const url = "https://charm.sh/"
 ```
 
 ## The Model
 
-Next we'll define our model. The only things we need to store are the status
+Next we’ll define our model. The only things we need to store are the status
 code of the HTTP response and a possible error.
 
 ```go
@@ -51,7 +51,7 @@ time, ticking a timer, reading from the disk, and network stuff are all I/O and
 should be run through commands. That might sound harsh, but it will keep your
 Bubble Tea program straightforward and simple.
 
-Anyway, let's write a `Cmd` that makes a request to a server and returns the
+Anyway, let’s write a `Cmd` that makes a request to a server and returns the
 result as a `Msg`.
 
 ```go
@@ -80,19 +80,19 @@ type errMsg struct{ err error }
 func (e errMsg) Error() string { return e.err.Error() }
 ```
 
-And notice that we've defined two new `Msg` types. They can be any type, even
-an empty struct. We'll come back to them later in our update function.
-First, let's write our initialization function.
+And notice that we’ve defined two new `Msg` types. They can be any type, even
+an empty struct. We’ll come back to them later in our update function.
+First, let’s write our initialization function.
 
 ## The Initialization Method
 
 The initialization method is very simple: we return the `Cmd` we made earlier.
-Note that we don't call the function; the Bubble Tea runtime will do that when
+Note that we don’t call the function; the Bubble Tea runtime will do that when
 the time is right.
 
 ```go
-func (m model) Init() (tea.Model, tea.Cmd) {
-    return m, checkServer
+func (m model) Init() tea.Cmd {
+    return checkServer
 }
 ```
 
@@ -138,13 +138,13 @@ func (m model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 ## The View Function
 
 Our view is very straightforward. We look at the current model and build a
-string accordingly:
+`tea.View` accordingly:
 
 ```go
-func (m model) View() string {
+func (m model) View() tea.View {
     // If there's an error, print it out and don't do anything else.
     if m.err != nil {
-        return fmt.Sprintf("\nWe had some trouble: %v\n\n", m.err)
+        return tea.NewView(fmt.Sprintf("\nWe had some trouble: %v\n\n", m.err))
     }
 
     // Tell the user we're doing something.
@@ -156,14 +156,14 @@ func (m model) View() string {
     }
 
     // Send off whatever we came up with above for rendering.
-    return "\n" + s + "\n\n"
+    return tea.NewView("\n" + s + "\n\n")
 }
 ```
 
 ## Run the program
 
-The only thing left to do is run the program, so let's do that! Our initial
-model doesn't need any data at all in this case, we just initialize it with
+The only thing left to do is run the program, so let’s do that! Our initial
+model doesn’t need any data at all in this case, we just initialize it with
 a `model` struct with default values.
 
 ```go
@@ -175,13 +175,13 @@ func main() {
 }
 ```
 
-And that's that. There's one more thing that is helpful to know about
+And that’s that. There’s one more thing that is helpful to know about
 `Cmd`s, though.
 
 ## One More Thing About Commands
 
-`Cmd`s are defined in Bubble Tea as `type Cmd func() Msg`. So they're just
-functions that don't take any arguments and return a `Msg`, which can be
+`Cmd`s are defined in Bubble Tea as `type Cmd func() Msg`. So they’re just
+functions that don’t take any arguments and return a `Msg`, which can be
 any type. If you need to pass arguments to a command, you just make a function
 that returns a command. For example:
 
@@ -209,7 +209,7 @@ func checkSomeUrl(url string) tea.Cmd {
 ```
 
 Anyway, just make sure you do as much stuff as you can in the innermost
-function, because that's the one that runs asynchronously.
+function, because that’s the one that runs asynchronously.
 
 ## Now What?
 
@@ -221,7 +221,7 @@ a component library for Bubble Tea.
 And, of course, check out the [Go Docs][docs].
 
 [bubbles]: https://github.com/charmbracelet/bubbles
-[docs]: https://pkg.go.dev/github.com/charmbracelet/bubbletea?tab=doc
+[docs]: https://pkg.go.dev/charm.land/bubbletea/v2?tab=doc
 [examples]: https://github.com/charmbracelet/bubbletea/tree/master/examples
 
 ## Additional Resources
@@ -231,7 +231,7 @@ And, of course, check out the [Go Docs][docs].
 
 ### Feedback
 
-We'd love to hear your thoughts on this tutorial. Feel free to drop us a note!
+We’d love to hear your thoughts on this tutorial. Feel free to drop us a note!
 
 - [Twitter](https://twitter.com/charmcli)
 - [The Fediverse](https://mastodon.social/@charmcli)

tutorials/commands/main.go

@@ -6,7 +6,7 @@ import (
 	"os"
 	"time"
 
-	tea "github.com/charmbracelet/bubbletea/v2"
+	tea "charm.land/bubbletea/v2"
 )
 
 const url = "https://charm.sh/"
@@ -58,16 +58,16 @@ func (m model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 	return m, nil
 }
 
-func (m model) View() string {
+func (m model) View() tea.View {
 	if m.err != nil {
-		return fmt.Sprintf("\nWe had some trouble: %v\n\n", m.err)
+		return tea.NewView(fmt.Sprintf("\nWe had some trouble: %v\n\n", m.err))
 	}
 
 	s := fmt.Sprintf("Checking %s ... ", url)
 	if m.status > 0 {
 		s += fmt.Sprintf("%d %s!", m.status, http.StatusText(m.status))
 	}
-	return "\n" + s + "\n\n"
+	return tea.NewView("\n" + s + "\n\n")
 }
 
 func main() {