jc-printer-sdk-ts 0.1.0 → 0.1.2

package/src/transport.ts

@@ -8,8 +8,10 @@ import type {
   PrintDocument,
   PrinterDevice,
   PrinterInfo,
+  PrinterReadiness,
   PrinterSdkCallback,
   PrinterState,
+  PrinterStatusSnapshot,
   ScanCallback,
 } from "./types.js";
 
@@ -70,6 +72,8 @@ export interface PrinterTransport {
   getPrintScaleMultiplier?(): MaybePromise<number>;
   getPrinterName?(): MaybePromise<string>;
   getPrinterInfo?(): MaybePromise<PrinterInfo | null>;
+  queryPrinterStatus?(timeoutMs?: number): MaybePromise<PrinterStatusSnapshot>;
+  canStartPrintJob?(timeoutMs?: number): MaybePromise<PrinterReadiness>;
   getPrinterState?(): MaybePromise<PrinterState>;
   waitPrinterState?(
     state: PrinterState,
@@ -149,6 +153,60 @@ function defaultPaperInfo(): PaperInfo {
   };
 }
 
+function createMemoryPrinterStatus(state: PrinterState): PrinterStatusSnapshot {
+  return {
+    connected: state !== "Disconnected",
+    state,
+    statusAvailable: false,
+  };
+}
+
+function createMemoryReadiness(state: PrinterState): PrinterReadiness {
+  const status = createMemoryPrinterStatus(state);
+  if (!status.connected) {
+    return {
+      canPrint: false,
+      code: "not_connected",
+      reason: "Printer is not connected.",
+      warnings: [],
+      state,
+      connected: false,
+      status,
+    };
+  }
+  if (state === "Printing") {
+    return {
+      canPrint: false,
+      code: "sdk_printing",
+      reason: "A print job is already in progress.",
+      warnings: [],
+      state,
+      connected: true,
+      status,
+    };
+  }
+  if (state === "Working") {
+    return {
+      canPrint: false,
+      code: "printer_working",
+      reason: "Printer is currently working.",
+      warnings: [],
+      state,
+      connected: true,
+      status,
+    };
+  }
+  return {
+    canPrint: true,
+    code: "status_unavailable",
+    reason: "Printer is connected; live hardware status is not available in this transport.",
+    warnings: [],
+    state,
+    connected: true,
+    status,
+  };
+}
+
 function dimensionsFromInfo(info: string): Pick<BitmapLike, "width" | "height"> {
   try {
     const parsed = JSON.parse(info) as {
@@ -425,6 +483,14 @@ export class MemoryPrinterTransport implements PrinterTransport {
     return clone(this.printerInfo);
   }
 
+  queryPrinterStatus(): PrinterStatusSnapshot {
+    return createMemoryPrinterStatus(this.printerState);
+  }
+
+  canStartPrintJob(): PrinterReadiness {
+    return createMemoryReadiness(this.printerState);
+  }
+
   getPrinterState(): PrinterState {
     return this.printerState;
   }

package/src/types.ts

@@ -137,6 +137,50 @@ export interface PaperInfo {
   tailLength: number;
 }
 
+export interface PrinterStatusSnapshot {
+  connected: boolean;
+  state: PrinterState;
+  statusAvailable: boolean;
+  responseCommand?: number;
+  rawData?: number[];
+  chargeLevel?: number;
+  temperature?: number;
+  lidClosed?: boolean;
+  paperInserted?: boolean;
+  paperRfidSuccess?: boolean;
+  ribbonInserted?: boolean;
+  ribbonRfidSuccess?: boolean;
+  wifiRssi?: number;
+  lightingErrorCode?: number;
+  voltageState?: number;
+}
+
+export type PrinterReadinessCode =
+  | "ready"
+  | "status_unavailable"
+  | "not_connected"
+  | "sdk_printing"
+  | "printer_working"
+  | "cover_open"
+  | "paper_missing"
+  | "voltage_error";
+
+export type PrinterReadinessWarningCode =
+  | "paper_rfid_failed"
+  | "ribbon_missing"
+  | "ribbon_rfid_failed"
+  | "lighting_error";
+
+export interface PrinterReadiness {
+  canPrint: boolean;
+  code: PrinterReadinessCode;
+  reason: string;
+  warnings: PrinterReadinessWarningCode[];
+  state: PrinterState;
+  connected: boolean;
+  status?: PrinterStatusSnapshot;
+}
+
 export interface ColorSupport {
   normalMode: number;
   rbMode: number;

package/src/web-bluetooth.d.ts

@@ -0,0 +1,44 @@
+interface BluetoothRequestDeviceFilter {
+  namePrefix?: string;
+  name?: string;
+  services?: string[];
+}
+
+interface BluetoothRequestDeviceOptions {
+  filters?: BluetoothRequestDeviceFilter[];
+  acceptAllDevices?: boolean;
+  optionalServices?: string[];
+}
+
+interface BluetoothRemoteGATTCharacteristic extends EventTarget {
+  readonly value?: DataView;
+  startNotifications(): Promise<BluetoothRemoteGATTCharacteristic>;
+  stopNotifications(): Promise<BluetoothRemoteGATTCharacteristic>;
+  writeValue(value: BufferSource): Promise<void>;
+  writeValueWithoutResponse(value: BufferSource): Promise<void>;
+}
+
+interface BluetoothRemoteGATTService {
+  getCharacteristic(characteristicUuid: string): Promise<BluetoothRemoteGATTCharacteristic>;
+}
+
+interface BluetoothRemoteGATTServer {
+  readonly connected: boolean;
+  connect(): Promise<BluetoothRemoteGATTServer>;
+  disconnect(): void;
+  getPrimaryService(serviceUuid: string): Promise<BluetoothRemoteGATTService>;
+}
+
+interface BluetoothDevice extends EventTarget {
+  readonly id: string;
+  readonly name?: string;
+  readonly gatt?: BluetoothRemoteGATTServer | null;
+}
+
+interface Bluetooth extends EventTarget {
+  requestDevice(options: BluetoothRequestDeviceOptions): Promise<BluetoothDevice>;
+}
+
+interface Navigator {
+  bluetooth?: Bluetooth;
+}