text protocol basically done

src/escpos.gleam

···
 import escpos/protocol
 import gleam/bit_array
-import gleam/result
-import mug
+import gleam/bool
+
+pub opaque type CommandBuffer {
+  CommandBuffer(data: BitArray)
+}
+
+pub fn new() -> CommandBuffer {
+  CommandBuffer(<<>>)
+}
+
+pub fn write(cb: CommandBuffer, text: String) -> CommandBuffer {
+  append(cb, bit_array.from_string(text))
+}
+
+pub fn writeln(cb: CommandBuffer, text: String) -> CommandBuffer {
+  append(cb, bit_array.from_string(text))
+  |> 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 underline(
+  cb: CommandBuffer,
+  commands: fn(CommandBuffer) -> CommandBuffer,
+) -> CommandBuffer {
+  append(cb, protocol.underline(True))
+  |> commands
+  |> append(protocol.underline(False))
+}
+
+pub fn double_strike(
+  cb: CommandBuffer,
+  commands: fn(CommandBuffer) -> CommandBuffer,
+) -> CommandBuffer {
+  append(cb, protocol.double_strike(True))
+  |> commands
+  |> append(protocol.double_strike(False))
+}
 
-pub opaque type Printer {
-  Printer(socket: mug.Socket)
+pub fn reverse(
+  cb: CommandBuffer,
+  commands: fn(CommandBuffer) -> CommandBuffer,
+) -> CommandBuffer {
+  append(cb, protocol.reverse(True))
+  |> commands
+  |> append(protocol.reverse(False))
 }
 
-pub opaque type CommandBuffer {
-  CommandBuffer(data: BitArray)
+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 smooth(
+  cb: CommandBuffer,
+  commands: fn(CommandBuffer) -> CommandBuffer,
+) -> CommandBuffer {
+  append(cb, protocol.smooth(True))
+  |> commands
+  |> append(protocol.smooth(False))
 }
 
-pub opaque type EscposError {
-  ConnectionFailed(mug.ConnectError)
-  DisconnectionFailed(mug.Error)
-  TransmissionError(mug.Error)
-  PrintError(mug.Error)
+pub fn flip(
+  cb: CommandBuffer,
+  commands: fn(CommandBuffer) -> CommandBuffer,
+) -> CommandBuffer {
+  append(cb, protocol.flip(True))
+  |> commands
+  |> append(protocol.flip(False))
 }
 
-pub fn connect(ip: String, port: Int) -> Result(Printer, EscposError) {
-  use socket <- result.try(
-    mug.new(ip, port)
-    |> mug.timeout(milliseconds: 500)
-    |> mug.connect()
-    |> result.map_error(ConnectionFailed),
-  )
+pub fn set_font(cb: CommandBuffer, font: protocol.Font) -> CommandBuffer {
+  append(cb, protocol.font(font))
+}
 
-  use _ <- result.try(
-    mug.send(socket, protocol.init)
-    |> result.map_error(TransmissionError),
-  )
+pub fn reset_font(cb: CommandBuffer) -> CommandBuffer {
+  append(cb, protocol.font(protocol.FontA))
+}
 
-  Ok(Printer(socket))
+pub fn set_align(cb: CommandBuffer, justify: protocol.Justify) -> CommandBuffer {
+  ensure_new_line(cb)
+  |> append(protocol.justify(justify))
 }
 
-pub fn new() -> CommandBuffer {
-  CommandBuffer(<<>>)
+pub fn set_text_size(
+  cb: CommandBuffer,
+  width: Int,
+  height: Int,
+) -> CommandBuffer {
+  append(cb, protocol.character_size(width, height))
 }
 
-pub fn write(cb: CommandBuffer, text: String) -> CommandBuffer {
-  bit_array.append(cb.data, bit_array.from_string(text))
-  |> CommandBuffer
+pub fn reset_text_size(cb: CommandBuffer) -> CommandBuffer {
+  append(cb, protocol.character_size(1, 1))
 }
 
 pub fn cut(cb: CommandBuffer) -> CommandBuffer {
-  bit_array.append(cb.data, protocol.full_cut)
-  |> CommandBuffer
+  line_feed(cb, 3)
+  |> append(protocol.full_cut)
 }
 
 pub fn partial_cut(cb: CommandBuffer) -> CommandBuffer {
-  bit_array.append(cb.data, protocol.partial_cut)
-  |> CommandBuffer
+  line_feed(cb, 3)
+  |> append(protocol.partial_cut)
+}
+
+pub fn new_line(cb: CommandBuffer) -> CommandBuffer {
+  append(cb, protocol.lf)
 }
 
 pub fn line_feed(cb: CommandBuffer, lines: Int) -> CommandBuffer {
-  bit_array.append(cb.data, protocol.line_feed(lines))
+  append(cb, protocol.line_feed(lines))
+}
+
+pub fn reset(cb: CommandBuffer) -> CommandBuffer {
+  append(cb, protocol.init)
+}
+
+pub fn custom(cb: CommandBuffer, data: BitArray) -> CommandBuffer {
+  append(cb, data)
+}
+
+fn append(cb: CommandBuffer, data: BitArray) -> CommandBuffer {
+  bit_array.append(cb.data, data)
   |> CommandBuffer
 }
 
-pub fn print(cb: CommandBuffer, printer: Printer) -> Result(Nil, EscposError) {
-  let data = bit_array.append(cb.data, protocol.cr)
+pub fn get_payload(cb: CommandBuffer) -> BitArray {
+  ensure_new_line(cb).data
+}
 
-  mug.send(printer.socket, data)
-  |> result.map_error(PrintError)
+fn ensure_new_line(cb: CommandBuffer) -> CommandBuffer {
+  case is_new_line(cb) {
+    True -> cb
+    False -> new_line(cb)
+  }
 }
 
-pub fn disconnect(printer: Printer) -> Result(Nil, EscposError) {
-  mug.shutdown(printer.socket)
-  |> result.map_error(DisconnectionFailed)
+fn is_new_line(cb: CommandBuffer) -> Bool {
+  use <- bool.guard(cb.data == <<>>, True)
+  case bit_array.slice(cb.data, -1, 3) {
+    Ok(<<27, "d", _>>) -> True
+    Ok(<<_, _, 10>>) -> True
+    _ -> False
+  }
 }

src/escpos/printer.gleam

···
+import escpos.{type CommandBuffer}
+import escpos/protocol
+import gleam/result
+import mug
+
+pub opaque type Printer {
+  Printer(socket: mug.Socket)
+}
+
+pub opaque type PrinterError {
+  ConnectionFailed(mug.ConnectError)
+  DisconnectionFailed(mug.Error)
+  TransmissionError(mug.Error)
+  PrintError(mug.Error)
+}
+
+pub fn connect(ip: String, port: Int) -> Result(Printer, PrinterError) {
+  use socket <- result.try(
+    mug.new(ip, port)
+    |> mug.timeout(milliseconds: 500)
+    |> mug.connect()
+    |> result.map_error(ConnectionFailed),
+  )
+
+  use _ <- result.try(
+    mug.send(socket, protocol.init)
+    |> result.map_error(TransmissionError),
+  )
+
+  Ok(Printer(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)
+  |> result.map_error(PrintError)
+}
+
+pub fn disconnect(printer: Printer) -> Result(Nil, PrinterError) {
+  mug.shutdown(printer.socket)
+  |> result.map_error(DisconnectionFailed)
+}

src/escpos/protocol.gleam

···
+import gleam/int
+
+pub type Justify {
+  Left
+  Center
+  Right
+}
+
+pub type Font {
+  FontA
+  FontB
+  FontC
+  FontD
+  FontE
+  SpecialFontA
+  SpecialFontB
+}
+
 const esc = 27
 
 const gs = 29
···
 
 pub const lf = <<10>>
 
-pub const cr = <<13>>
-
 pub const full_cut = <<gs, "V", 0>>
 
 pub const partial_cut = <<gs, "V", 1>>
 
 pub fn line_feed(lines: Int) -> BitArray {
   case lines {
-    l if l < 2 -> lf
-    l if l > 255 -> <<esc, "d", 255>>
+    l if l < 2 -> <<esc, "d", 1>>
+    l if l > 254 -> <<esc, "d", 255>>
     _ -> <<esc, "d", lines>>
   }
 }
+
+/// requires to be on a new line to take effect
+pub fn justify(justify: Justify) -> BitArray {
+  case justify {
+    Left -> <<esc, "a", 0>>
+    Center -> <<esc, "a", 1>>
+    Right -> <<esc, "a", 2>>
+  }
+}
+
+pub fn bold(on: Bool) -> BitArray {
+  case on {
+    True -> <<esc, "E", 1>>
+    False -> <<esc, "E", 0>>
+  }
+}
+
+pub fn underline(on: Bool) -> BitArray {
+  case on {
+    True -> <<esc, "-", 1>>
+    False -> <<esc, "-", 0>>
+  }
+}
+
+pub fn double_strike(on: Bool) -> BitArray {
+  case on {
+    True -> <<esc, "G", 1>>
+    False -> <<esc, "G", 0>>
+  }
+}
+
+pub fn reverse(on: Bool) -> BitArray {
+  case on {
+    True -> <<gs, "B", 1>>
+    False -> <<gs, "B", 0>>
+  }
+}
+
+pub fn upside_down(on: Bool) -> BitArray {
+  case on {
+    True -> <<esc, "{", 1>>
+    False -> <<esc, "{", 0>>
+  }
+}
+
+pub fn smooth(on: Bool) -> BitArray {
+  case on {
+    True -> <<gs, "b", 1>>
+    False -> <<gs, "b", 0>>
+  }
+}
+
+pub fn flip(on: Bool) -> BitArray {
+  case on {
+    True -> <<esc, "V", 1>>
+    False -> <<esc, "V", 0>>
+  }
+}
+
+pub fn font(font: Font) -> BitArray {
+  case font {
+    FontA -> <<esc, "M", 0>>
+    FontB -> <<esc, "M", 1>>
+    FontC -> <<esc, "M", 2>>
+    FontD -> <<esc, "M", 3>>
+    FontE -> <<esc, "M", 4>>
+    SpecialFontA -> <<esc, "M", 97>>
+    SpecialFontB -> <<esc, "M", 98>>
+  }
+}
+
+pub fn character_size(width: Int, height: Int) -> BitArray {
+  let w = int.clamp(width, min: 1, max: 8) |> int.subtract(1)
+  let h = int.clamp(height, min: 1, max: 8) |> int.subtract(1)
+  <<gs, "!", 0:1, w:3, 0:1, h:3>>
+}

test/escpos_test.gleam

···
 import escpos
+import escpos/printer
+import escpos/protocol
 import gleeunit
 
 pub fn main() -> Nil {
   gleeunit.main()
 }
 
+fn setup_printer() -> Result(printer.Printer, printer.PrinterError) {
+  printer.connect("10.255.8.62", 9100)
+}
+
+fn test_print(
+  printer: printer.Printer,
+  name: String,
+  commands: fn(escpos.CommandBuffer) -> escpos.CommandBuffer,
+) {
+  escpos.new()
+  |> escpos.writeln("----- " <> name)
+  |> commands
+  |> escpos.new_line
+  |> printer.print(printer)
+}
+
 pub fn print_test() {
-  let assert Ok(printer) = escpos.connect("localhost", 9100)
+  let assert Ok(printer) = setup_printer()
 
   let assert Ok(Nil) =
-    escpos.new()
-    |> escpos.write("Hello, World!")
-    |> escpos.line_feed(2)
-    |> escpos.partial_cut()
-    |> escpos.print(printer)
+    test_print(printer, "writeln", escpos.write(_, "Hello, World!"))
 
-  escpos.disconnect(printer)
+  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) {
+      escpos.set_font(b, protocol.FontB)
+      |> escpos.write("Hello, World!")
+      |> escpos.reset_font
+    })
+
+  let assert Ok(Nil) =
+    test_print(printer, "font C", fn(b) {
+      escpos.set_font(b, protocol.FontC)
+      |> escpos.write("Hello, World!")
+      |> escpos.reset_font
+    })
+
+  let assert Ok(Nil) =
+    test_print(printer, "high text size", fn(b) {
+      escpos.set_text_size(b, 1, 8)
+      |> escpos.write("Hello, World!")
+      |> escpos.reset_text_size
+    })
+
+  let assert Ok(Nil) =
+    test_print(printer, "wide text size", fn(b) {
+      escpos.set_text_size(b, 8, 1)
+      |> escpos.write("Hello, World!")
+      |> escpos.reset_text_size
+    })
+
+  let assert Ok(Nil) =
+    test_print(printer, "large text size", fn(b) {
+      escpos.set_text_size(b, 3, 3)
+      |> escpos.write("Hello, World!")
+      |> escpos.reset_text_size
+    })
+
+  let assert Ok(Nil) =
+    test_print(printer, "line feed 5", escpos.line_feed(_, 1))
+
+  let assert Ok(Nil) = test_print(printer, "partial cut", escpos.partial_cut)
+
+  printer.disconnect(printer)
+}
+
+pub fn protocol_character_size_test() {
+  assert protocol.character_size(2, 2) == <<29, "!", 0:1, 1:3, 0:1, 1:3>>
+  assert protocol.character_size(20, 20) == <<29, "!", 0:1, 7:3, 0:1, 7:3>>
 }