@esslassi/electron-printer 0.0.6 → 0.0.8

package/src/windows_printer.cpp

@@ -1,49 +1,15 @@
 #include "windows_printer.h"
+
 #include <vector>
+#include <string>
+#include <map>
+#include <fstream>
+#include <sstream>
+#include <algorithm>
 
-std::string WindowsPrinter::GetPrinterStatus(DWORD status)
-{
-    if (status & PRINTER_STATUS_OFFLINE)
-        return "offline";
-    if (status & PRINTER_STATUS_ERROR)
-        return "error";
-    if (status & PRINTER_STATUS_PAPER_JAM)
-        return "paper-jam";
-    if (status & PRINTER_STATUS_PAPER_OUT)
-        return "paper-out";
-    if (status & PRINTER_STATUS_MANUAL_FEED)
-        return "manual-feed";
-    if (status & PRINTER_STATUS_PAPER_PROBLEM)
-        return "paper-problem";
-    if (status & PRINTER_STATUS_BUSY)
-        return "busy";
-    if (status & PRINTER_STATUS_PRINTING)
-        return "printing";
-    if (status & PRINTER_STATUS_OUTPUT_BIN_FULL)
-        return "output-bin-full";
-    if (status & PRINTER_STATUS_NOT_AVAILABLE)
-        return "not-available";
-    if (status & PRINTER_STATUS_WAITING)
-        return "waiting";
-    if (status & PRINTER_STATUS_PROCESSING)
-        return "processing";
-    if (status & PRINTER_STATUS_INITIALIZING)
-        return "initializing";
-    if (status & PRINTER_STATUS_WARMING_UP)
-        return "warming-up";
-    if (status & PRINTER_STATUS_TONER_LOW)
-        return "toner-low";
-    if (status & PRINTER_STATUS_NO_TONER)
-        return "no-toner";
-    if (status & PRINTER_STATUS_PAGE_PUNT)
-        return "page-punt";
-    if (status & PRINTER_STATUS_USER_INTERVENTION)
-        return "user-intervention";
-    if (status & PRINTER_STATUS_OUT_OF_MEMORY)
-        return "out-of-memory";
-    if (status & PRINTER_STATUS_DOOR_OPEN)
-        return "door-open";
-    return "ready";
+static std::string ToUpper(std::string s) {
+    std::transform(s.begin(), s.end(), s.begin(), [](unsigned char c) { return (char)std::toupper(c); });
+    return s;
 }
 
 std::wstring WindowsPrinter::Utf8ToWide(const std::string &str)
@@ -72,139 +38,310 @@ std::string WindowsPrinter::WideToUtf8(LPWSTR wstr)
     return std::string(buffer.data());
 }
 
-PrinterInfo WindowsPrinter::GetPrinterDetails(const std::string &printerName, bool isDefault)
+static std::time_t SystemTimeToTimeT(const SYSTEMTIME &st)
 {
-    PrinterInfo info;
-    info.name = printerName;
-    info.isDefault = isDefault;
+    FILETIME ft;
+    if (!SystemTimeToFileTime(&st, &ft)) return 0;
 
-    HANDLE hPrinter;
-    std::wstring wPrinterName = Utf8ToWide(printerName);
+    ULARGE_INTEGER ull;
+    ull.LowPart = ft.dwLowDateTime;
+    ull.HighPart = ft.dwHighDateTime;
 
-    if (OpenPrinterW((LPWSTR)wPrinterName.c_str(), &hPrinter, NULL))
-    {
-        DWORD needed;
-        GetPrinterW(hPrinter, 2, NULL, 0, &needed);
-        if (needed > 0)
-        {
-            std::vector<BYTE> buffer(needed);
-            if (GetPrinterW(hPrinter, 2, buffer.data(), needed, &needed))
-            {
-                PRINTER_INFO_2W *pInfo = (PRINTER_INFO_2W *)buffer.data();
-                info.status = GetPrinterStatus(pInfo->Status);
-
-                if (pInfo->pLocation)
-                    info.details["location"] = WideToUtf8(pInfo->pLocation);
-                if (pInfo->pComment)
-                    info.details["comment"] = WideToUtf8(pInfo->pComment);
-                if (pInfo->pDriverName)
-                    info.details["driver"] = WideToUtf8(pInfo->pDriverName);
-                if (pInfo->pPortName)
-                    info.details["port"] = WideToUtf8(pInfo->pPortName);
-            }
-        }
-        ClosePrinter(hPrinter);
-    }
+    // Windows FILETIME is 100-ns since Jan 1, 1601 (UTC)
+    // Convert to Unix epoch (seconds since Jan 1, 1970)
+    const unsigned long long EPOCH_DIFFERENCE = 116444736000000000ULL; // 100ns
+    if (ull.QuadPart < EPOCH_DIFFERENCE) return 0;
 
-    return info;
+    unsigned long long unix100ns = ull.QuadPart - EPOCH_DIFFERENCE;
+    return (std::time_t)(unix100ns / 10000000ULL);
 }
 
-std::vector<PrinterInfo> WindowsPrinter::GetPrinters()
+std::vector<std::string> WindowsPrinter::MapJobStatus(DWORD status)
 {
-    std::vector<PrinterInfo> printers;
-    DWORD needed = 0, returned = 0;
+    std::vector<std::string> out;
+
+    if (status & JOB_STATUS_PAUSED) out.push_back("PAUSED");
+    if (status & JOB_STATUS_PRINTING) out.push_back("PRINTING");
+    if (status & JOB_STATUS_SPOOLING) out.push_back("PENDING");
+    if (status & JOB_STATUS_DELETING) out.push_back("CANCELLED");
+    if (status & JOB_STATUS_DELETED) out.push_back("CANCELLED");
+    if (status & JOB_STATUS_ERROR) out.push_back("ABORTED");
+    if (status & JOB_STATUS_OFFLINE) out.push_back("PENDING");
+    if (status & JOB_STATUS_PAPEROUT) out.push_back("PENDING");
+    if (status & JOB_STATUS_PRINTED) out.push_back("PRINTED");
 
+    if (out.empty()) out.push_back("PENDING");
+    return out;
+}
+
+static bool ReadAllBytes(const std::string &path, std::vector<uint8_t> &out)
+{
+    std::ifstream f(path, std::ios::binary);
+    if (!f) return false;
+    f.seekg(0, std::ios::end);
+    std::streamsize size = f.tellg();
+    if (size < 0) return false;
+    f.seekg(0, std::ios::beg);
+
+    out.resize((size_t)size);
+    if (size > 0)
+        f.read((char*)out.data(), size);
+
+    return true;
+}
+
+std::vector<PrinterDetailsNative> WindowsPrinter::GetPrinters()
+{
+    std::vector<PrinterDetailsNative> printers;
+
+    DWORD needed = 0, returned = 0;
     EnumPrintersW(PRINTER_ENUM_LOCAL | PRINTER_ENUM_CONNECTIONS, NULL, 2, NULL, 0, &needed, &returned);
-    if (needed > 0)
+    if (needed == 0) return printers;
+
+    std::vector<BYTE> buffer(needed);
+    if (!EnumPrintersW(PRINTER_ENUM_LOCAL | PRINTER_ENUM_CONNECTIONS, NULL, 2, buffer.data(), needed, &needed, &returned))
+        return printers;
+
+    wchar_t defaultPrinter[512];
+    DWORD defaultSize = (DWORD)(sizeof(defaultPrinter) / sizeof(defaultPrinter[0]));
+    std::string defaultName;
+    if (GetDefaultPrinterW(defaultPrinter, &defaultSize))
+        defaultName = WideToUtf8(defaultPrinter);
+
+    PRINTER_INFO_2W *pInfo = (PRINTER_INFO_2W *)buffer.data();
+
+    for (DWORD i = 0; i < returned; i++)
     {
-        std::vector<BYTE> buffer(needed);
-        if (EnumPrintersW(PRINTER_ENUM_LOCAL | PRINTER_ENUM_CONNECTIONS, NULL, 2, buffer.data(), needed, &needed, &returned))
-        {
-            PRINTER_INFO_2W *pInfo = (PRINTER_INFO_2W *)buffer.data();
-            for (DWORD i = 0; i < returned; i++)
-            {
-                std::string name = WideToUtf8(pInfo[i].pPrinterName);
-                bool isDefault = false;
-
-                wchar_t defaultPrinter[256];
-                DWORD size = sizeof(defaultPrinter) / sizeof(defaultPrinter[0]);
-                if (GetDefaultPrinterW(defaultPrinter, &size))
-                {
-                    isDefault = (wcscmp(pInfo[i].pPrinterName, defaultPrinter) == 0);
-                }
-
-                printers.push_back(GetPrinterDetails(name, isDefault));
-            }
-        }
+        PrinterDetailsNative p;
+        p.name = WideToUtf8(pInfo[i].pPrinterName);
+        p.isDefault = (!defaultName.empty() && p.name == defaultName);
+
+        // options: keep it clean and stable
+        if (pInfo[i].pLocation) p.options["location"] = WideToUtf8(pInfo[i].pLocation);
+        if (pInfo[i].pComment) p.options["comment"] = WideToUtf8(pInfo[i].pComment);
+        if (pInfo[i].pDriverName) p.options["driver"] = WideToUtf8(pInfo[i].pDriverName);
+        if (pInfo[i].pPortName) p.options["port"] = WideToUtf8(pInfo[i].pPortName);
+
+        printers.push_back(std::move(p));
     }
 
     return printers;
 }
 
-PrinterInfo WindowsPrinter::GetSystemDefaultPrinter()
+PrinterDetailsNative WindowsPrinter::GetPrinter(const std::string &printerName)
 {
-    wchar_t printerName[256];
-    DWORD size = sizeof(printerName) / sizeof(printerName[0]);
+    // Build from GetPrinters (stable + consistent)
+    auto list = GetPrinters();
+    for (auto &p : list)
+    {
+        if (p.name == printerName) return p;
+    }
 
+    PrinterDetailsNative p;
+    p.name = printerName;
+    p.isDefault = false;
+    return p;
+}
+
+std::string WindowsPrinter::GetDefaultPrinterName()
+{
+    wchar_t printerName[512];
+    DWORD size = (DWORD)(sizeof(printerName) / sizeof(printerName[0]));
     if (GetDefaultPrinterW(printerName, &size))
+        return WideToUtf8(printerName);
+    return "";
+}
+
+DriverOptions WindowsPrinter::GetPrinterDriverOptions(const std::string &printerName)
+{
+    // Windows driver option enumeration is complex (DEVMODE / DocumentProperties).
+    // For now: return empty, still satisfies your TS typing.
+    // You can enhance later with DEVMODE-driven options.
+    (void)printerName;
+    return DriverOptions{};
+}
+
+std::string WindowsPrinter::GetSelectedPaperSize(const std::string &printerName)
+{
+    HANDLE hPrinter = NULL;
+    std::wstring wName = Utf8ToWide(printerName);
+
+    if (!OpenPrinterW((LPWSTR)wName.c_str(), &hPrinter, NULL))
+        return "";
+
+    // Query DEVMODE size
+    LONG dmSize = DocumentPropertiesW(NULL, hPrinter, (LPWSTR)wName.c_str(), NULL, NULL, 0);
+    if (dmSize <= 0)
+    {
+        ClosePrinter(hPrinter);
+        return "";
+    }
+
+    std::vector<BYTE> dmBuffer((size_t)dmSize);
+    DEVMODEW *dm = (DEVMODEW *)dmBuffer.data();
+
+    LONG res = DocumentPropertiesW(NULL, hPrinter, (LPWSTR)wName.c_str(), dm, NULL, DM_OUT_BUFFER);
+    if (res != IDOK)
+    {
+        ClosePrinter(hPrinter);
+        return "";
+    }
+
+    std::string paper;
+
+    if ((dm->dmFields & DM_FORMNAME) && dm->dmFormName[0] != L'\0')
+    {
+        paper = WideToUtf8(dm->dmFormName);
+    }
+    else if (dm->dmFields & DM_PAPERSIZE)
     {
-        std::string name = WideToUtf8(printerName);
-        return GetPrinterDetails(name, true);
+        // Fallback: return numeric code as string (still useful)
+        paper = std::to_string((int)dm->dmPaperSize);
     }
 
-    return PrinterInfo();
+    ClosePrinter(hPrinter);
+    return paper;
 }
 
-bool WindowsPrinter::PrintDirect(const std::string &printerName, const std::vector<uint8_t> &data, const std::string &dataType)
+std::vector<std::string> WindowsPrinter::GetSupportedPrintFormats()
 {
-    HANDLE hPrinter;
+    // On Windows spooler, “RAW” is always safe. PDF/JPEG/PS conversion is not guaranteed without extra pipeline.
+    return { "RAW", "TEXT", "COMMAND" };
+}
+
+int WindowsPrinter::PrintDirect(const std::string &printerName,
+                                const std::vector<uint8_t> &data,
+                                const std::string &type,
+                                const StringMap &options)
+{
+    (void)options;
+
+    HANDLE hPrinter = NULL;
     std::wstring wPrinterName = Utf8ToWide(printerName);
-    std::wstring wDataType = Utf8ToWide(dataType);
 
     if (!OpenPrinterW((LPWSTR)wPrinterName.c_str(), &hPrinter, NULL))
-    {
-        return false;
-    }
+        return 0;
+
+    std::string t = ToUpper(type);
+    // Windows expects a spool datatype string. For our types:
+    // RAW/TEXT/COMMAND => use RAW to send bytes directly.
+    std::wstring wDataType = Utf8ToWide("RAW");
 
     DOC_INFO_1W docInfo;
-    wchar_t docName[] = L"Node.js Print Job";
+    wchar_t docName[] = L"Node Print Job";
     docInfo.pDocName = docName;
     docInfo.pOutputFile = NULL;
-    docInfo.pDatatype = const_cast<LPWSTR>(wDataType.c_str());
+    docInfo.pDatatype = (LPWSTR)wDataType.c_str();
+
+    DWORD jobId = StartDocPrinterW(hPrinter, 1, (LPBYTE)&docInfo);
+    if (jobId == 0)
+    {
+        ClosePrinter(hPrinter);
+        return 0;
+    }
 
-    if (StartDocPrinterW(hPrinter, 1, (LPBYTE)&docInfo))
+    if (!StartPagePrinter(hPrinter))
     {
-        if (StartPagePrinter(hPrinter))
-        {
-            DWORD bytesWritten;
-            void *buffer = const_cast<void *>(static_cast<const void *>(data.data()));
-            if (WritePrinter(hPrinter, buffer, static_cast<DWORD>(data.size()), &bytesWritten))
-            {
-                EndPagePrinter(hPrinter);
-                EndDocPrinter(hPrinter);
-                ClosePrinter(hPrinter);
-                return true;
-            }
-        }
         EndDocPrinter(hPrinter);
+        ClosePrinter(hPrinter);
+        return 0;
+    }
+
+    DWORD bytesWritten = 0;
+    BOOL ok = WritePrinter(hPrinter, (LPVOID)data.data(), (DWORD)data.size(), &bytesWritten);
+
+    EndPagePrinter(hPrinter);
+    EndDocPrinter(hPrinter);
+    ClosePrinter(hPrinter);
+
+    if (!ok || bytesWritten != (DWORD)data.size())
+        return 0;
+
+    return (int)jobId;
+}
+
+int WindowsPrinter::PrintFile(const std::string &printerName,
+                              const std::string &filename)
+{
+    std::vector<uint8_t> data;
+    if (!ReadAllBytes(filename, data))
+        return 0;
+
+    // PrintFile typing does not include type, so we treat it as RAW bytes.
+    StringMap emptyOpts;
+    return PrintDirect(printerName, data, "RAW", emptyOpts);
+}
+
+JobDetailsNative WindowsPrinter::GetJob(const std::string &printerName, int jobId)
+{
+    JobDetailsNative j;
+    j.id = jobId;
+    j.printerName = printerName;
+
+    HANDLE hPrinter = NULL;
+    std::wstring wPrinterName = Utf8ToWide(printerName);
+    if (!OpenPrinterW((LPWSTR)wPrinterName.c_str(), &hPrinter, NULL))
+        return j;
+
+    DWORD needed = 0;
+    GetJobW(hPrinter, (DWORD)jobId, 2, NULL, 0, &needed);
+    if (needed == 0)
+    {
+        ClosePrinter(hPrinter);
+        return j;
+    }
+
+    std::vector<BYTE> buffer(needed);
+    if (!GetJobW(hPrinter, (DWORD)jobId, 2, buffer.data(), needed, &needed))
+    {
+        ClosePrinter(hPrinter);
+        return j;
     }
 
+    JOB_INFO_2W *ji = (JOB_INFO_2W *)buffer.data();
+
+    j.name = ji->pDocument ? WideToUtf8(ji->pDocument) : "";
+    j.user = ji->pUserName ? WideToUtf8(ji->pUserName) : "";
+    j.format = "RAW";
+    j.priority = (int)ji->Priority;
+    j.size = (int)ji->Size;
+    j.status = MapJobStatus(ji->Status);
+
+    // Times
+    j.creationTime = SystemTimeToTimeT(ji->Submitted);
+    j.processingTime = j.creationTime;
+    j.completedTime = 0;
+
     ClosePrinter(hPrinter);
-    return false;
+    return j;
 }
 
-PrinterInfo WindowsPrinter::GetStatusPrinter(const std::string &printerName)
+void WindowsPrinter::SetJob(const std::string &printerName, int jobId, const std::string &command)
 {
-    wchar_t defaultPrinter[256];
-    DWORD size = sizeof(defaultPrinter) / sizeof(defaultPrinter[0]);
-    bool isDefault = false;
+    HANDLE hPrinter = NULL;
+    std::wstring wPrinterName = Utf8ToWide(printerName);
+    if (!OpenPrinterW((LPWSTR)wPrinterName.c_str(), &hPrinter, NULL))
+        return;
+
+    std::string cmd = ToUpper(command);
 
-    if (GetDefaultPrinterW(defaultPrinter, &size))
+    if (cmd == "CANCEL")
+    {
+        SetJobW(hPrinter, (DWORD)jobId, 0, NULL, JOB_CONTROL_CANCEL);
+    }
+    else if (cmd == "PAUSE")
+    {
+        SetJobW(hPrinter, (DWORD)jobId, 0, NULL, JOB_CONTROL_PAUSE);
+    }
+    else if (cmd == "RESUME")
     {
-        std::string defaultPrinterName = WideToUtf8(defaultPrinter);
-        isDefault = (printerName == defaultPrinterName);
+        SetJobW(hPrinter, (DWORD)jobId, 0, NULL, JOB_CONTROL_RESUME);
     }
 
-    PrinterInfo printer = GetPrinterDetails(printerName, isDefault);
-    return printer;
+    ClosePrinter(hPrinter);
 }
+
+std::vector<std::string> WindowsPrinter::GetSupportedJobCommands()
+{
+    return { "CANCEL", "PAUSE", "RESUME" };
+}

package/src/windows_printer.h

@@ -1,14 +1,16 @@
 #ifndef WINDOWS_PRINTER_H
 #define WINDOWS_PRINTER_H
 
-#define NOMINMAX
+#include "printer_interface.h"
+
 #include <windows.h>
 #include <winspool.h>
-#include <cstdint>
-#include "printer_interface.h"
-#include <vector>
 
-// Desabilita todas as macros do Windows que podem interferir
+/* Now remove macro pollution */
+#ifdef GetDefaultPrinter
+#undef GetDefaultPrinter
+#endif
+
 #ifdef GetDefaultPrinter
 #undef GetDefaultPrinter
 #endif
@@ -17,19 +19,46 @@
 #undef GetPrinter
 #endif
 
+#ifdef GetJob
+#undef GetJob
+#endif
+
+#ifdef SetJob
+#undef SetJob
+#endif
+
+#include <vector>
+#include <string>
+#include <cstdint>
+
 class WindowsPrinter : public PrinterInterface
 {
 private:
-    std::string GetPrinterStatus(DWORD status);
     std::wstring Utf8ToWide(const std::string &str);
     std::string WideToUtf8(LPWSTR wstr);
+    std::vector<std::string> MapJobStatus(DWORD status);
 
 public:
-    virtual PrinterInfo GetPrinterDetails(const std::string &printerName, bool isDefault = false) override;
-    virtual std::vector<PrinterInfo> GetPrinters() override;
-    virtual PrinterInfo GetSystemDefaultPrinter() override;
-    virtual bool PrintDirect(const std::string &printerName, const std::vector<uint8_t> &data, const std::string &dataType) override;
-    virtual PrinterInfo GetStatusPrinter(const std::string &printerName) override;
+    std::vector<PrinterDetailsNative> GetPrinters() override;
+    PrinterDetailsNative GetPrinter(const std::string &printerName) override;
+    std::string GetDefaultPrinterName() override;
+
+    DriverOptions GetPrinterDriverOptions(const std::string &printerName) override;
+    std::string GetSelectedPaperSize(const std::string &printerName) override;
+
+    int PrintDirect(const std::string &printerName,
+                    const std::vector<uint8_t> &data,
+                    const std::string &type,
+                    const StringMap &options) override;
+
+    int PrintFile(const std::string &printerName,
+                  const std::string &filename) override;
+
+    std::vector<std::string> GetSupportedPrintFormats() override;
+
+    JobDetailsNative GetJob(const std::string &printerName, int jobId) override;
+    void SetJob(const std::string &printerName, int jobId, const std::string &command) override;
+    std::vector<std::string> GetSupportedJobCommands() override;
 };
 
 #endif

package/test.js

@@ -0,0 +1,120 @@
+const printer = require('./lib'); 
+
+async function run() {
+  console.log("===== TEST START =====");
+
+  // -------------------------------------------------
+  // 1️⃣ Get printers (sync)
+  // -------------------------------------------------
+  const printers = printer.getPrinters();
+  console.log("Printers:", printers);
+
+  if (!printers.length) {
+    console.log("No printers found. Exiting.");
+    return;
+  }
+
+  const defaultPrinter = printer.getDefaultPrinterName();
+  console.log("Default printer:", defaultPrinter);
+
+  const selectedPrinter = defaultPrinter || printers[0].name;
+  console.log("Using printer:", selectedPrinter);
+
+  // -------------------------------------------------
+  // 2️⃣ Get single printer
+  // -------------------------------------------------
+  const printerDetails = printer.getPrinter(selectedPrinter);
+  console.log("Printer details:", printerDetails);
+
+  // -------------------------------------------------
+  // 3️⃣ Driver options
+  // -------------------------------------------------
+  const driverOptions = printer.getPrinterDriverOptions(selectedPrinter);
+  console.log("Driver options:", driverOptions);
+
+  // -------------------------------------------------
+  // 4️⃣ Paper size
+  // -------------------------------------------------
+  const paper = printer.getSelectedPaperSize(selectedPrinter);
+  console.log("Selected paper size:", paper);
+
+  // -------------------------------------------------
+  // 5️⃣ Supported formats
+  // -------------------------------------------------
+  console.log("Supported formats:", printer.getSupportedPrintFormats());
+
+  // -------------------------------------------------
+  // 6️⃣ Supported job commands
+  // -------------------------------------------------
+  console.log("Supported job commands:", printer.getSupportedJobCommands());
+
+  // -------------------------------------------------
+  // 7️⃣ printDirect (callback version)
+  // -------------------------------------------------
+  printer.printDirect({
+    data: "TEST PRINT FROM CALLBACK\n\n",
+    printer: selectedPrinter,
+    type: "RAW",
+    success: (jobId) => {
+      console.log("printDirect success jobId:", jobId);
+
+      const job = printer.getJob(selectedPrinter, parseInt(jobId));
+      console.log("Job details (sync):", job);
+
+      // Try cancel test (optional)
+      // printer.setJob(selectedPrinter, parseInt(jobId), "CANCEL");
+    },
+    error: (err) => {
+      console.error("printDirect error:", err);
+    }
+  });
+
+  // -------------------------------------------------
+  // 8️⃣ printDirectAsync
+  // -------------------------------------------------
+  try {
+    const jobId = await printer.printDirectAsync({
+      data: Buffer.from("TEST PRINT FROM ASYNC\n\n"),
+      printer: selectedPrinter,
+      type: "RAW"
+    });
+
+    console.log("printDirectAsync jobId:", jobId);
+
+    const jobAsync = await printer.getJobAsync(selectedPrinter, parseInt(jobId));
+    console.log("Job details (async):", jobAsync);
+
+  } catch (err) {
+    console.error("printDirectAsync error:", err);
+  }
+
+  // -------------------------------------------------
+  // 9️⃣ printFileAsync
+  // -------------------------------------------------
+  try {
+    const jobId = await printer.printFileAsync({
+      filename: "./sample.txt", // make sure this exists
+      printer: selectedPrinter
+    });
+
+    console.log("printFileAsync jobId:", jobId);
+  } catch (err) {
+    console.error("printFileAsync error:", err);
+  }
+
+  // -------------------------------------------------
+  // 🔟 getPrintersAsync
+  // -------------------------------------------------
+  const printersAsync = await printer.getPrintersAsync();
+  console.log("Printers (async):", printersAsync);
+
+  // -------------------------------------------------
+  // 11️⃣ getPrinterAsync
+  // -------------------------------------------------
+  const singlePrinterAsync = await printer.getPrinterAsync(selectedPrinter);
+  console.log("Single printer (async):", singlePrinterAsync);
+
+  console.log("===== TEST END =====");
+}
+
+run().catch(console.error);