label-printer 0.6.0 → 0.7.0

package/dist/index.js

@@ -34,15 +34,15 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target2) => (target2 = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+var __toESM = (mod2, isNodeMode, target2) => (target2 = mod2 != null ? __create(__getProtoOf(mod2)) : {}, __copyProps(
   // If the importer is in node compatibility mode or this is not an ESM
   // file that has been converted to a CommonJS file using a Babel-
   // compatible transform (i.e. "__esModule" has not been set), then set
   // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target2, "default", { value: mod, enumerable: true }) : target2,
-  mod
+  isNodeMode || !mod2 || !mod2.__esModule ? __defProp(target2, "default", { value: mod2, enumerable: true }) : target2,
+  mod2
 ));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __toCommonJS = (mod2) => __copyProps(__defProp({}, "__esModule", { value: true }), mod2);
 var __async = (__this, __arguments, generator) => {
   return new Promise((resolve, reject) => {
     var fulfilled = (value) => {
@@ -87,10 +87,10 @@ var Command = class {
     fn(this.commandString);
   }
   /**
-   * Write the command data to a USB device
+   * Write the command data to a device
    * @param device Device to write to
    */
-  write(device) {
+  writeTo(device) {
     return __async(this, null, function* () {
       yield this.writeString(this.commandString, device);
       yield this.terminateCommand(device);
@@ -144,10 +144,10 @@ var CommandGroup = class extends Command {
       this.commands[commandIndex].print(fn);
     }
   }
-  write(device) {
+  writeTo(device) {
     return __async(this, null, function* () {
       for (let commandIndex in this.commands) {
-        yield this.commands[commandIndex].write(device);
+        yield this.commands[commandIndex].writeTo(device);
       }
     });
   }
@@ -968,7 +968,7 @@ var TSPLBitmapCommand = class _TSPLBitmapCommand extends TSPLVisualCommand {
         return 2;
     }
   }
-  write(device) {
+  writeTo(device) {
     return __async(this, null, function* () {
       yield this.writeString(this.commandWithoutBytes, device);
       yield this.writeBytes(this.bitmap.bytes, device);
@@ -1149,7 +1149,7 @@ var TSPLDownload = class extends TSPLCommand {
   get commandString() {
     return `DOWNLOAD "${this.fileName}", ${this.data.byteLength},`;
   }
-  write(device) {
+  writeTo(device) {
     return __async(this, null, function* () {
       yield this.writeString(this.commandString, device);
       yield this.writeBytes(this.data, device);
@@ -1333,14 +1333,14 @@ __export(printers_exports, {
 // src/printers/Printer.ts
 var Printer = class {
   constructor(device) {
-    this.usbDevice = device;
+    this.device = device;
   }
   /**
    * Close the printer USB
    */
   close() {
     return __async(this, null, function* () {
-      yield this.usbDevice.close();
+      yield this.device.close();
     });
   }
   /**
@@ -1369,8 +1369,8 @@ var Printer = class {
    */
   writeCommand(command) {
     return __async(this, null, function* () {
-      if (!this.usbDevice.opened) yield this.usbDevice.openAndConfigure();
-      yield command.write(this.usbDevice);
+      if (!this.device.opened) yield this.device.openAndConfigure();
+      yield command.writeTo(this.device);
     });
   }
   /**
@@ -1538,8 +1538,214 @@ var UsbDevice = class {
   }
 };
 
+// src/helpers/NetworkDevice.ts
+var unsupportedNetworkError = "network-unsupported";
+var stringHelper2 = new StringUtils();
+var getNet = () => {
+  if (typeof window !== "undefined") {
+    throw unsupportedNetworkError;
+  }
+  return eval("require")("net");
+};
+var NetworkDevice = class {
+  /**
+   * Create a TCP-based device.
+   *
+   * This is intended for raw printing ports (typically 9100). It is Node-only.
+   *
+   * @param host Hostname or IP
+   * @param port TCP port (defaults to 9100)
+   * @param connectTimeoutMs Connection timeout
+   * @param readTimeoutMs Read timeout used by `readData`/`readString`
+   */
+  constructor(host, port = 9100, connectTimeoutMs = 2e3, readTimeoutMs = 500) {
+    this.host = host;
+    this.port = port;
+    this.connectTimeoutMs = connectTimeoutMs;
+    this.readTimeoutMs = readTimeoutMs;
+  }
+  get opened() {
+    return !!this.socket;
+  }
+  openAndConfigure() {
+    return __async(this, null, function* () {
+      if (this.socket) return;
+      const net = getNet();
+      yield new Promise((resolve, reject) => {
+        let settled = false;
+        const timeout = setTimeout(() => {
+          var _a;
+          if (settled) return;
+          settled = true;
+          try {
+            (_a = this.socket) == null ? void 0 : _a.destroy();
+          } catch (_e) {
+          }
+          this.socket = void 0;
+          reject(new Error("network-connect-timeout"));
+        }, this.connectTimeoutMs);
+        try {
+          const socket = net.createConnection({ host: this.host, port: this.port }, () => {
+            if (settled) return;
+            settled = true;
+            clearTimeout(timeout);
+            resolve();
+          });
+          socket.once("error", (err) => {
+            if (settled) return;
+            settled = true;
+            clearTimeout(timeout);
+            this.socket = void 0;
+            reject(err);
+          });
+          this.socket = socket;
+        } catch (e) {
+          if (settled) return;
+          settled = true;
+          clearTimeout(timeout);
+          this.socket = void 0;
+          reject(e);
+        }
+      });
+    });
+  }
+  close() {
+    return __async(this, null, function* () {
+      if (!this.socket) return;
+      const socket = this.socket;
+      this.socket = void 0;
+      try {
+        socket.end();
+      } catch (_e) {
+        try {
+          socket.destroy();
+        } catch (_e2) {
+        }
+      }
+    });
+  }
+  writeData(data) {
+    return __async(this, null, function* () {
+      if (!this.socket) {
+        throw new Error("network-not-open");
+      }
+      yield new Promise((resolve, reject) => {
+        try {
+          this.socket.write(data, (err) => {
+            if (err) reject(err);
+            else resolve();
+          });
+        } catch (e) {
+          reject(e);
+        }
+      });
+    });
+  }
+  writeString(text) {
+    return __async(this, null, function* () {
+      const bytes = stringHelper2.toUTF8Array(text);
+      yield this.writeData(bytes);
+    });
+  }
+  readData(length) {
+    return __async(this, null, function* () {
+      if (!this.socket) {
+        throw new Error("network-not-open");
+      }
+      const socket = this.socket;
+      const buffer2 = yield new Promise((resolve, reject) => {
+        let settled = false;
+        const onData = (data) => {
+          if (settled) return;
+          settled = true;
+          cleanup();
+          resolve(data);
+        };
+        const onError = (err) => {
+          if (settled) return;
+          settled = true;
+          cleanup();
+          reject(err);
+        };
+        const cleanup = () => {
+          clearTimeout(timeout);
+          socket.removeListener("data", onData);
+          socket.removeListener("error", onError);
+        };
+        const timeout = setTimeout(() => {
+          if (settled) return;
+          settled = true;
+          cleanup();
+          resolve(void 0);
+        }, this.readTimeoutMs);
+        socket.once("data", onData);
+        socket.once("error", onError);
+      });
+      if (!buffer2) return void 0;
+      if (buffer2.byteLength > length) return void 0;
+      return new DataView(buffer2.buffer.slice(buffer2.byteOffset, buffer2.byteOffset + buffer2.byteLength));
+    });
+  }
+  readString(length) {
+    return __async(this, null, function* () {
+      const bytes = yield this.readData(length);
+      if (bytes) return stringHelper2.toString(bytes);
+      return void 0;
+    });
+  }
+};
+
+// src/helpers/BonjourUtils.ts
+var unsupportedBonjourError = "bonjour-unsupported";
+var getBonjour = () => {
+  var _a;
+  if (typeof window !== "undefined") {
+    throw unsupportedBonjourError;
+  }
+  const mod = eval("require")("bonjour");
+  const factory = mod && ((_a = mod.default) != null ? _a : mod);
+  if (typeof factory !== "function") {
+    throw new Error("bonjour-invalid-module");
+  }
+  return factory;
+};
+var discoverBonjourServices = (types, timeoutMs = 1500) => __async(null, null, function* () {
+  if (typeof window !== "undefined") return [];
+  const factory2 = getBonjour();
+  const bonjour = factory2();
+  try {
+    const results = [];
+    const seen = /* @__PURE__ */ new Set();
+    const browsers = types.map((type) => {
+      return bonjour.find({ type }, (service) => {
+        var _a;
+        const host = ((_a = service == null ? void 0 : service.referer) == null ? void 0 : _a.address) || (service == null ? void 0 : service.host);
+        const port = service == null ? void 0 : service.port;
+        if (!host || !port) return;
+        const key = `${host}:${port}`;
+        if (seen.has(key)) return;
+        seen.add(key);
+        results.push({ host, port, name: service == null ? void 0 : service.name, type });
+      });
+    });
+    yield new Promise((resolve) => setTimeout(resolve, timeoutMs));
+    for (const browser of browsers) {
+      try {
+        browser.stop();
+      } catch (_e) {
+      }
+    }
+    return results;
+  } finally {
+    try {
+      bonjour.destroy();
+    } catch (_e) {
+    }
+  }
+});
+
 // src/printers/TSPLPrinter.ts
-var TSPLPrinter = class extends Printer {
+var TSPLPrinter = class _TSPLPrinter extends Printer {
   get language() {
     return "tspl";
   }
@@ -1553,12 +1759,152 @@ var TSPLPrinter = class extends Printer {
     return __async(this, null, function* () {
       if (!device.opened) yield device.openAndConfigure();
       const testCommand = new TSPLRawCommand("~!I");
-      yield testCommand.write(device);
+      yield testCommand.writeTo(device);
       const response = yield device.readString(64);
       yield device.close();
       return !!response;
     });
   }
+  /**
+   * Discover TSPL-capable printers on the local network.
+   *
+   * Strategy:
+   * - Use Bonjour/mDNS to discover "printer-ish" services to obtain a set of candidate hosts.
+   * - For each unique host, probe TCP/9100 by sending the TSPL identify command (~!I).
+   * - Only return devices that respond to the TSPL probe.
+   * - If Bonjour yields no candidates (e.g. mDNS is blocked), fall back to a conservative
+   *   subnet scan on local private /24 networks (still verified by the same TSPL probe).
+   */
+  static discoverDevices() {
+    return __async(this, null, function* () {
+      if (typeof window !== "undefined") return [];
+      const services = yield discoverBonjourServices([
+        "pdl-datastream",
+        "printer",
+        "ipp",
+        "ipps"
+      ]);
+      let uniqueHosts = Array.from(new Set(services.map((s) => s.host).filter(Boolean)));
+      if (uniqueHosts.length === 0) {
+        uniqueHosts = yield _TSPLPrinter.discoverHostsBySubnetScan();
+      }
+      const candidates = uniqueHosts.map((host) => ({ host, port: 9100 }));
+      const concurrency = 5;
+      const verified = [];
+      for (let i = 0; i < candidates.length; i += concurrency) {
+        const batch = candidates.slice(i, i + concurrency);
+        const results = yield Promise.all(batch.map((c) => __async(null, null, function* () {
+          const device = new NetworkDevice(c.host, c.port, 4e3, 1e3);
+          try {
+            const ok = yield _TSPLPrinter.try(device);
+            return ok ? device : void 0;
+          } catch (_e) {
+            try {
+              yield device.close();
+            } catch (_e2) {
+            }
+            return void 0;
+          }
+        })));
+        verified.push(...results.filter(Boolean));
+      }
+      return verified;
+    });
+  }
+  /**
+   * Fallback discovery mechanism used when Bonjour/mDNS returns no printer candidates.
+   *
+   * It derives local private IPv4 /24 prefixes from the current machine's network interfaces
+   * and probes TCP/9100 using the TSPL identify command.
+   *
+   * The scan is intentionally conservative:
+   * - Limited number of prefixes
+   * - Concurrency limits
+   * - Total time cap
+   * - Early-exit when at least one printer is found
+   */
+  static discoverHostsBySubnetScan() {
+    return __async(this, null, function* () {
+      var _a, _b, _c;
+      if (typeof window !== "undefined") return [];
+      const req = _TSPLPrinter.getNodeRequire();
+      if (!req) return [];
+      const os = req("os");
+      const networkInterfaces = (_b = (_a = os.networkInterfaces) == null ? void 0 : _a.call(os)) != null ? _b : {};
+      const privatePrefixes = /* @__PURE__ */ new Set();
+      const isPrivateIpv4 = (ip) => {
+        if (ip.startsWith("10.")) return true;
+        if (ip.startsWith("192.168.")) return true;
+        const m = ip.match(/^172\.(\d+)\./);
+        if (m) {
+          const n = Number(m[1]);
+          return n >= 16 && n <= 31;
+        }
+        return false;
+      };
+      for (const key of Object.keys(networkInterfaces)) {
+        const infos = (_c = networkInterfaces[key]) != null ? _c : [];
+        for (const info of infos) {
+          const family = info == null ? void 0 : info.family;
+          const address = info == null ? void 0 : info.address;
+          const internal = info == null ? void 0 : info.internal;
+          if (internal) continue;
+          if (family !== "IPv4") continue;
+          if (typeof address !== "string") continue;
+          if (!isPrivateIpv4(address)) continue;
+          const parts = address.split(".");
+          if (parts.length !== 4) continue;
+          privatePrefixes.add(`${parts[0]}.${parts[1]}.${parts[2]}`);
+        }
+      }
+      const prefixes = Array.from(privatePrefixes).slice(0, 2);
+      if (prefixes.length === 0) return [];
+      const hosts = [];
+      for (const prefix of prefixes) {
+        for (let i = 1; i <= 254; i++) {
+          hosts.push(`${prefix}.${i}`);
+        }
+      }
+      const concurrency = 30;
+      const verifiedHosts = [];
+      const startedAt = Date.now();
+      const maxDurationMs = 15e3;
+      for (let i = 0; i < hosts.length; i += concurrency) {
+        if (Date.now() - startedAt > maxDurationMs) break;
+        if (verifiedHosts.length > 0) break;
+        const batch = hosts.slice(i, i + concurrency);
+        const results = yield Promise.all(batch.map((host) => __async(null, null, function* () {
+          const device = new NetworkDevice(host, 9100, 800, 800);
+          try {
+            const ok = yield _TSPLPrinter.try(device);
+            return ok ? host : void 0;
+          } catch (_e) {
+            try {
+              yield device.close();
+            } catch (_e2) {
+            }
+            return void 0;
+          }
+        })));
+        verifiedHosts.push(...results.filter(Boolean));
+      }
+      return verifiedHosts;
+    });
+  }
+  /**
+   * Returns a Node-style `require` function.
+   *
+   * This is used to keep runtime dependencies Node-only while still allowing the library to
+   * be imported/bundled in browser contexts.
+   *
+   * Tests may inject a custom require implementation via `globalThis.__label_printer_require`.
+   */
+  static getNodeRequire() {
+    if (typeof window !== "undefined") return void 0;
+    const override = globalThis.__label_printer_require;
+    if (typeof override === "function") return override;
+    return eval("require");
+  }
 };
 
 // src/printers/PrinterService.ts
@@ -1583,12 +1929,40 @@ var PrinterService = class _PrinterService {
       return void 0;
     });
   }
+  /**
+   * Discover devices using printer-specific discovery hooks.
+   *
+   * Each printer class may optionally implement `static discoverDevices(): Promise<Device[]>`
+   * to find candidates over non-USB transports.
+   *
+   * Candidates returned here are still verified by `printerForDevice` via the printer
+   * class' `try(device)` method.
+   */
+  static discoverDevices() {
+    return __async(this, null, function* () {
+      const classes = [TSPLPrinter];
+      const discoveryResults = yield Promise.all(classes.map((cls) => __async(null, null, function* () {
+        const discoverer = cls.discoverDevices;
+        if (typeof discoverer === "function") {
+          try {
+            return yield discoverer.call(cls);
+          } catch (_e) {
+            return [];
+          }
+        }
+        return [];
+      })));
+      return discoveryResults.flat();
+    });
+  }
   /**
    * @returns List of available printers
    */
   static getPrinters() {
     return __async(this, null, function* () {
-      const devices = yield getDevices();
+      const usbDevices = yield getDevices();
+      const discoveredDevices = yield _PrinterService.discoverDevices();
+      const devices = [...usbDevices, ...discoveredDevices];
       const optionalPrinters = yield Promise.all(devices.map(_PrinterService.printerForDevice));
       return optionalPrinters.filter((printer) => !!printer);
     });