feat: document api

src/escpos.gleam

···
+import escpos/printer.{type CommandBuffer, CommandBuffer}
 import escpos/protocol
 import gleam/bit_array
 import gleam/bool
-
-pub opaque type CommandBuffer {
-  CommandBuffer(data: BitArray)
-}
 
 pub fn new() -> CommandBuffer {
   CommandBuffer(<<>>)
···
   |> append(protocol.lf)
 }
 
-pub fn bold(
-  cb: CommandBuffer,
-  commands: fn(CommandBuffer) -> CommandBuffer,
-) -> CommandBuffer {
-  append(cb, protocol.bold(True))
-  |> commands
-  |> append(protocol.bold(False))
+pub fn bold(cb: CommandBuffer, b: Bool) -> CommandBuffer {
+  append(cb, protocol.bold(b))
 }
 
-pub fn underline(
-  cb: CommandBuffer,
-  commands: fn(CommandBuffer) -> CommandBuffer,
-) -> CommandBuffer {
-  append(cb, protocol.underline(True))
-  |> commands
-  |> append(protocol.underline(False))
+pub fn underline(cb: CommandBuffer, b: Bool) -> CommandBuffer {
+  append(cb, protocol.underline(b))
 }
 
-pub fn double_strike(
-  cb: CommandBuffer,
-  commands: fn(CommandBuffer) -> CommandBuffer,
-) -> CommandBuffer {
-  append(cb, protocol.double_strike(True))
-  |> commands
-  |> append(protocol.double_strike(False))
+pub fn double_strike(cb: CommandBuffer, b: Bool) -> CommandBuffer {
+  append(cb, protocol.double_strike(b))
 }
 
-pub fn reverse(
-  cb: CommandBuffer,
-  commands: fn(CommandBuffer) -> CommandBuffer,
-) -> CommandBuffer {
-  append(cb, protocol.reverse(True))
-  |> commands
-  |> append(protocol.reverse(False))
+pub fn reverse(cb: CommandBuffer, b: Bool) -> CommandBuffer {
+  append(cb, protocol.reverse(b))
 }
 
-pub fn upside_down(
-  cb: CommandBuffer,
-  commands: fn(CommandBuffer) -> CommandBuffer,
-) -> CommandBuffer {
-  append(cb, protocol.upside_down(True))
-  |> commands
-  |> ensure_new_line
-  |> append(protocol.upside_down(False))
+pub fn upside_down(cb: CommandBuffer, b: Bool) -> CommandBuffer {
+  append(cb, protocol.upside_down(b))
 }
 
-pub fn smooth(
-  cb: CommandBuffer,
-  commands: fn(CommandBuffer) -> CommandBuffer,
-) -> CommandBuffer {
-  append(cb, protocol.smooth(True))
-  |> commands
-  |> append(protocol.smooth(False))
+pub fn smooth(cb: CommandBuffer, b: Bool) -> CommandBuffer {
+  append(cb, protocol.smooth(b))
 }
 
-pub fn flip(
-  cb: CommandBuffer,
-  commands: fn(CommandBuffer) -> CommandBuffer,
-) -> CommandBuffer {
-  append(cb, protocol.flip(True))
-  |> commands
-  |> append(protocol.flip(False))
+pub fn flip(cb: CommandBuffer, b: Bool) -> CommandBuffer {
+  append(cb, protocol.flip(b))
 }
 
 pub fn set_font(cb: CommandBuffer, font: protocol.Font) -> CommandBuffer {
···
 
 pub fn cut(cb: CommandBuffer) -> CommandBuffer {
   line_feed(cb, 3)
-  |> append(protocol.full_cut)
+  |> append(protocol.cut(protocol.Full))
 }
 
 pub fn partial_cut(cb: CommandBuffer) -> CommandBuffer {
   line_feed(cb, 3)
-  |> append(protocol.partial_cut)
+  |> append(protocol.cut(protocol.Partial))
 }
 
 pub fn new_line(cb: CommandBuffer) -> CommandBuffer {
···
 fn append(cb: CommandBuffer, data: BitArray) -> CommandBuffer {
   bit_array.append(cb.data, data)
   |> CommandBuffer
-}
-
-pub fn get_payload(cb: CommandBuffer) -> BitArray {
-  ensure_new_line(cb).data
 }
 
 fn ensure_new_line(cb: CommandBuffer) -> CommandBuffer {

src/escpos/document.gleam

···
+import escpos/printer.{type CommandBuffer, CommandBuffer}
+import escpos/protocol
+import gleam/bit_array
+import gleam/list
+import gleam/option.{type Option, None, Some}
+import gleam/set.{type Set}
+
+pub opaque type Command {
+  Write(String)
+  Writeln(String)
+  LineFeed(Int)
+  Cut(protocol.Cut)
+  Styled(modifiers: Set(Modifier), commands: List(Command))
+  Custom(BitArray)
+}
+
+pub opaque type Modifier {
+  Bold
+  Underline
+  DoubleStrike
+  Reverse
+  UpsideDown
+  Justify(protocol.Justify)
+  Font(protocol.Font)
+}
+
+pub opaque type AST {
+  Init
+  DoWrite(String)
+  DoLineFeed(Int)
+  DoCut(protocol.Cut)
+  DoCustom(BitArray)
+  SetBold(Bool)
+  SetUnderline(Bool)
+  SetDoubleStrike(Bool)
+  SetReverse(Bool)
+  SetUpsideDown(Bool)
+  SetJustify(protocol.Justify)
+  SetFont(protocol.Font)
+}
+
+type State {
+  State(
+    new_line: Bool,
+    bold: Bool,
+    underline: Bool,
+    double_strike: Bool,
+    reverse: Bool,
+    upside_down: Bool,
+    justify: protocol.Justify,
+    font: protocol.Font,
+  )
+}
+
+fn default_state() -> State {
+  State(
+    new_line: True,
+    bold: False,
+    underline: False,
+    double_strike: False,
+    reverse: False,
+    upside_down: False,
+    justify: protocol.Left,
+    font: protocol.FontA,
+  )
+}
+
+pub fn build(document: List(Command)) -> CommandBuffer {
+  build_ast(document)
+  |> compile_ast
+  |> CommandBuffer
+}
+
+pub fn styled(modifiers: List(Modifier), commands: List(Command)) -> Command {
+  Styled(set.from_list(modifiers), commands)
+}
+
+pub fn write(text: String) -> Command {
+  Write(text)
+}
+
+pub fn writeln(text: String) -> Command {
+  Writeln(text)
+}
+
+pub fn line_feed(lines: Int) -> Command {
+  LineFeed(lines)
+}
+
+pub fn cut() -> Command {
+  Cut(protocol.Full)
+}
+
+pub fn partial_cut() -> Command {
+  Cut(protocol.Partial)
+}
+
+pub fn bold() -> Modifier {
+  Bold
+}
+
+pub fn underline() -> Modifier {
+  Underline
+}
+
+pub fn double_strike() -> Modifier {
+  DoubleStrike
+}
+
+pub fn reverse() -> Modifier {
+  Reverse
+}
+
+pub fn upside_down() -> Modifier {
+  UpsideDown
+}
+
+pub fn justify(j: protocol.Justify) -> Modifier {
+  Justify(j)
+}
+
+pub fn font(f: protocol.Font) -> Modifier {
+  Font(f)
+}
+
+fn build_ast(commands: List(Command)) -> List(AST) {
+  do_build_ast(commands, [Init], default_state())
+  |> list.reverse
+}
+
+fn do_build_ast(
+  commands: List(Command),
+  acc: List(AST),
+  state: State,
+) -> List(AST) {
+  case commands {
+    [] -> acc
+    [cmd, ..rest] -> {
+      case cmd {
+        Styled(modifiers, commands) -> {
+          let #(acc_with_mods, nested_state) =
+            do_apply_modifiers(set.to_list(modifiers), acc, state)
+          let acc_with_commands =
+            do_build_ast(commands, acc_with_mods, nested_state)
+          let #(acc_with_reset_styles, reset_state) =
+            revert_styles(state, nested_state, acc_with_commands)
+          do_build_ast(
+            rest,
+            acc_with_reset_styles,
+            State(..state, new_line: reset_state.new_line),
+          )
+        }
+        Cut(c) -> {
+          let new_acc =
+            list.prepend(acc, DoLineFeed(3)) |> list.prepend(DoCut(c))
+          do_build_ast(rest, new_acc, State(..state, new_line: True))
+        }
+        LineFeed(n) ->
+          do_build_ast(
+            rest,
+            [DoLineFeed(n), ..acc],
+            State(..state, new_line: True),
+          )
+        Write(x) ->
+          do_build_ast(
+            rest,
+            [DoWrite(x), ..acc],
+            State(..state, new_line: False),
+          )
+        Writeln(x) -> {
+          let new_acc =
+            list.prepend(acc, DoWrite(x)) |> list.prepend(DoLineFeed(1))
+          do_build_ast(rest, new_acc, State(..state, new_line: True))
+        }
+        Custom(b) ->
+          do_build_ast(
+            rest,
+            [DoCustom(b), ..acc],
+            State(..state, new_line: False),
+          )
+      }
+    }
+  }
+}
+
+fn revert_styles(
+  state: State,
+  nested_state: State,
+  acc: List(AST),
+) -> #(List(AST), State) {
+  let changes =
+    [
+      changed(state.bold != nested_state.bold, SetBold(state.bold)),
+      changed(
+        state.underline != nested_state.underline,
+        SetUnderline(state.underline),
+      ),
+      changed(
+        state.double_strike != nested_state.double_strike,
+        SetDoubleStrike(state.double_strike),
+      ),
+      changed(state.reverse != nested_state.reverse, SetReverse(state.reverse)),
+      changed(
+        state.upside_down != nested_state.upside_down,
+        SetUpsideDown(state.upside_down),
+      ),
+      changed(state.justify != nested_state.justify, SetJustify(state.justify)),
+      changed(state.font != nested_state.font, SetFont(state.font)),
+    ]
+    |> option.values
+
+  do_revert_styles(changes, acc, state)
+}
+
+fn do_revert_styles(
+  changes: List(AST),
+  acc: List(AST),
+  state: State,
+) -> #(List(AST), State) {
+  case changes {
+    [] -> #(acc, state)
+    [style, ..rest] ->
+      case style {
+        SetJustify(_) | SetUpsideDown(_) ->
+          case state.new_line {
+            True -> do_revert_styles(rest, [style, ..acc], state)
+            False ->
+              do_revert_styles(
+                rest,
+                list.prepend(acc, DoLineFeed(1)) |> list.prepend(style),
+                State(..state, new_line: True),
+              )
+          }
+        _ -> do_revert_styles(rest, [style, ..acc], state)
+      }
+  }
+}
+
+fn changed(change: Bool, ast: AST) -> Option(AST) {
+  case change {
+    True -> Some(ast)
+    False -> None
+  }
+}
+
+fn do_apply_modifiers(
+  modifiers: List(Modifier),
+  acc: List(AST),
+  state: State,
+) -> #(List(AST), State) {
+  case modifiers {
+    [] -> #(acc, state)
+    [mod, ..rest] -> {
+      case mod {
+        Bold ->
+          do_apply_modifiers(
+            rest,
+            [SetBold(True), ..acc],
+            State(..state, bold: True),
+          )
+        DoubleStrike ->
+          do_apply_modifiers(
+            rest,
+            [SetDoubleStrike(True), ..acc],
+            State(..state, double_strike: True),
+          )
+        Underline ->
+          do_apply_modifiers(
+            rest,
+            [SetUnderline(True), ..acc],
+            State(..state, underline: True),
+          )
+        Reverse ->
+          do_apply_modifiers(
+            rest,
+            [SetReverse(True), ..acc],
+            State(..state, reverse: True),
+          )
+        UpsideDown ->
+          case state.new_line {
+            True ->
+              do_apply_modifiers(
+                rest,
+                [SetUpsideDown(True), ..acc],
+                State(..state, upside_down: True, new_line: True),
+              )
+            False ->
+              do_apply_modifiers(
+                rest,
+                list.prepend(acc, DoLineFeed(1))
+                  |> list.prepend(SetUpsideDown(True)),
+                State(..state, upside_down: True),
+              )
+          }
+        Justify(j) ->
+          case state.new_line {
+            True ->
+              do_apply_modifiers(
+                rest,
+                [SetJustify(j), ..acc],
+                State(..state, justify: j, new_line: True),
+              )
+            False ->
+              do_apply_modifiers(
+                rest,
+                list.prepend(acc, DoLineFeed(1)) |> list.prepend(SetJustify(j)),
+                State(..state, justify: j),
+              )
+          }
+        Font(f) ->
+          do_apply_modifiers(rest, [SetFont(f), ..acc], State(..state, font: f))
+      }
+    }
+  }
+}
+
+fn compile_ast(ast: List(AST)) -> BitArray {
+  do_compile_ast(ast, <<>>)
+}
+
+fn do_compile_ast(ast: List(AST), acc: BitArray) -> BitArray {
+  case ast {
+    [] -> acc
+    [cmd, ..rest] ->
+      case cmd {
+        Init -> do_compile_ast(rest, bit_array.append(acc, protocol.init))
+        DoWrite(x) ->
+          do_compile_ast(rest, bit_array.append(acc, bit_array.from_string(x)))
+        DoLineFeed(n) ->
+          do_compile_ast(rest, bit_array.append(acc, protocol.line_feed(n)))
+        DoCut(c) -> do_compile_ast(rest, bit_array.append(acc, protocol.cut(c)))
+        DoCustom(b) -> do_compile_ast(rest, bit_array.append(acc, b))
+        SetBold(on) ->
+          do_compile_ast(rest, bit_array.append(acc, protocol.bold(on)))
+        SetUnderline(on) ->
+          do_compile_ast(rest, bit_array.append(acc, protocol.underline(on)))
+        SetDoubleStrike(on) ->
+          do_compile_ast(
+            rest,
+            bit_array.append(acc, protocol.double_strike(on)),
+          )
+        SetReverse(on) ->
+          do_compile_ast(rest, bit_array.append(acc, protocol.reverse(on)))
+        SetUpsideDown(on) ->
+          do_compile_ast(rest, bit_array.append(acc, protocol.upside_down(on)))
+        SetJustify(j) ->
+          do_compile_ast(rest, bit_array.append(acc, protocol.justify(j)))
+        SetFont(f) ->
+          do_compile_ast(rest, bit_array.append(acc, protocol.font(f)))
+      }
+  }
+}

src/escpos/printer.gleam

···
-import escpos.{type CommandBuffer}
 import escpos/protocol
 import gleam/result
 import mug
+
+@internal
+pub type CommandBuffer {
+  CommandBuffer(data: BitArray)
+}
 
 pub opaque type Printer {
   Printer(socket: mug.Socket)
···
 
 /// Sends the CommandBuffer to the printer
 pub fn print(cb: CommandBuffer, printer: Printer) -> Result(Nil, PrinterError) {
-  let data = escpos.get_payload(cb)
-
-  mug.send(printer.socket, data)
+  mug.send(printer.socket, cb.data)
   |> result.map_error(PrintError)
 }
 

src/escpos/protocol.gleam

···
   Right
 }
 
+pub type Cut {
+  Partial
+  Full
+}
+
 pub type Font {
   FontA
   FontB
···
 
 pub const lf = <<10>>
 
-pub const full_cut = <<gs, "V", 0>>
-
-pub const partial_cut = <<gs, "V", 1>>
+pub fn cut(cut: Cut) -> BitArray {
+  case cut {
+    Full -> <<gs, "V", 0>>
+    Partial -> <<gs, "V", 1>>
+  }
+}
 
 pub fn line_feed(lines: Int) -> BitArray {
   case lines {

test/escpos_test.gleam

···
 }
 
 fn setup_printer() -> Result(printer.Printer, printer.PrinterError) {
-  printer.connect("10.255.8.62", 9100)
+  printer.connect("localhost", 9100)
 }
 
 fn test_print(
···
 
   let assert Ok(Nil) =
     test_print(printer, "writeln", escpos.write(_, "Hello, World!"))
-
-  let assert Ok(Nil) =
-    test_print(
-      printer,
-      "write bold",
-      escpos.bold(_, escpos.write(_, "Hello, World!")),
-    )
-
-  let assert Ok(Nil) =
-    test_print(
-      printer,
-      "write underline",
-      escpos.underline(_, escpos.write(_, "Hello, World!")),
-    )
-
-  let assert Ok(Nil) =
-    test_print(
-      printer,
-      "write double strike",
-      escpos.double_strike(_, escpos.write(_, "Hello, World!")),
-    )
-
-  let assert Ok(Nil) =
-    test_print(
-      printer,
-      "write reverse",
-      escpos.reverse(_, escpos.write(_, "Hello, World!")),
-    )
-
-  let assert Ok(Nil) =
-    test_print(
-      printer,
-      "write upside down",
-      escpos.upside_down(_, escpos.write(_, "Hello, World!")),
-    )
 
   let assert Ok(Nil) =
     test_print(printer, "font B", fn(b) {