node-hp-scan-to 1.3.1 → 1.4.1

package/src/WalkupScanDestination.ts

@@ -5,7 +5,7 @@ import { KnownShortcut } from "./KnownShortcut";
 
 const parser = new Parser();
 const parseString = promisify<string, WalkupScanDestinationsData>(
-  parser.parseString
+  parser.parseString,
 );
 
 interface WalkupScanDestinationsData {
@@ -32,11 +32,11 @@ export default class WalkupScanDestination {
     this.data = data;
   }
   static async createWalkupScanDestination(
-    content: string
+    content: string,
   ): Promise<WalkupScanDestination> {
     const parsed = await parseString(content);
     return new WalkupScanDestination(
-      parsed["wus:WalkupScanDestinations"]["wus:WalkupScanDestination"][0]
+      parsed["wus:WalkupScanDestinations"]["wus:WalkupScanDestination"][0],
     );
   }
 
@@ -53,14 +53,18 @@ export default class WalkupScanDestination {
   }
 
   get shortcut(): null | KnownShortcut {
-    if (this.data.hasOwnProperty("wus:WalkupScanSettings")) {
+    if (
+      Object.prototype.hasOwnProperty.call(this.data, "wus:WalkupScanSettings")
+    ) {
       return this.data["wus:WalkupScanSettings"]["0"]["wus:Shortcut"][0];
     }
     return null;
   }
 
   get scanPlexMode(): string | null {
-    if (this.data.hasOwnProperty("wus:WalkupScanSettings")) {
+    if (
+      Object.prototype.hasOwnProperty.call(this.data, "wus:WalkupScanSettings")
+    ) {
       return this.data["wus:WalkupScanSettings"]["0"][
         "scantype:ScanSettings"
       ][0]["dd:ScanPlexMode"][0];

package/src/WalkupScanDestinations.ts

@@ -3,7 +3,7 @@ import { Parser } from "xml2js";
 const parser = new Parser();
 import { promisify } from "util";
 const parseString = promisify<string, WalkupScanDestinationsData>(
-  parser.parseString
+  parser.parseString,
 );
 
 import WalkupScanDestination, {
@@ -22,7 +22,7 @@ export default class WalkupScanDestinations {
     this.data = data;
   }
   static async createWalkupScanDestinations(
-    content: string
+    content: string,
   ): Promise<WalkupScanDestinations> {
     const parsed = await parseString(content);
     return new WalkupScanDestinations(parsed);
@@ -30,9 +30,14 @@ export default class WalkupScanDestinations {
 
   get destinations(): WalkupScanDestination[] {
     let walkupScanDestinations = this.data["wus:WalkupScanDestinations"];
-    if (walkupScanDestinations.hasOwnProperty("wus:WalkupScanDestination")) {
+    if (
+      Object.prototype.hasOwnProperty.call(
+        walkupScanDestinations,
+        "wus:WalkupScanDestination",
+      )
+    ) {
       return walkupScanDestinations["wus:WalkupScanDestination"].map(
-        (x) => new WalkupScanDestination(x)
+        (x) => new WalkupScanDestination(x),
       );
     } else {
       return [];

package/src/WalkupScanManifest.ts

@@ -3,7 +3,7 @@ import { Parser } from "xml2js";
 const parser = new Parser();
 import { promisify } from "util";
 const parseString = promisify<string, WalkupScanManifestData>(
-  parser.parseString
+  parser.parseString,
 );
 
 export interface WalkupScanManifestData {
@@ -31,7 +31,7 @@ export default class WalkupScanManifest {
     this.data = data;
   }
   static async createWalkupScanManifest(
-    content: string
+    content: string,
   ): Promise<WalkupScanManifest> {
     const parsed = await parseString(content);
     return new WalkupScanManifest(parsed);
@@ -43,7 +43,7 @@ export default class WalkupScanManifest {
     ]["map:ResourceNode"].find(
       (x) =>
         x["map:ResourceType"][0]["wus:WalkupScanResourceType"][0] ===
-        "WalkupScanDestinations"
+        "WalkupScanDestinations",
     );
 
     if (walkupScanToCompCaps === undefined) {

package/src/WalkupScanToCompCaps.ts

@@ -3,7 +3,7 @@ import { Parser } from "xml2js";
 const parser = new Parser();
 import { promisify } from "util";
 const parseString = promisify<string, WalkupScanToCompCapsData>(
-  parser.parseString
+  parser.parseString,
 );
 export interface WalkupScanToCompCapsData {
   "wus:WalkupScanToCompCaps": {
@@ -20,7 +20,7 @@ export default class WalkupScanToCompCaps {
   }
 
   static async createWalkupScanToCompCaps(
-    content: string
+    content: string,
   ): Promise<WalkupScanToCompCaps> {
     const parsed = await parseString(content);
     return new WalkupScanToCompCaps(parsed);

package/src/WalkupScanToCompDestination.ts

@@ -4,7 +4,7 @@ const parser = new Parser();
 import { promisify } from "util";
 import { KnownShortcut } from "./KnownShortcut";
 const parseString = promisify<string, WalkupScanToCompDestinationRoot>(
-  parser.parseString
+  parser.parseString,
 );
 
 interface WalkupScanToCompDestinationRoot {
@@ -29,11 +29,11 @@ export default class WalkupScanToCompDestination {
     this.data = data;
   }
   static async createWalkupScanToCompDestination(
-    content: string
+    content: string,
   ): Promise<WalkupScanToCompDestination> {
     const parsed = await parseString(content);
     return new WalkupScanToCompDestination(
-      parsed["wus:WalkupScanToCompDestination"]
+      parsed["wus:WalkupScanToCompDestination"],
     );
   }
 
@@ -50,14 +50,24 @@ export default class WalkupScanToCompDestination {
   }
 
   get shortcut(): null | KnownShortcut {
-    if (this.data.hasOwnProperty("wus:WalkupScanToCompSettings")) {
+    if (
+      Object.prototype.hasOwnProperty.call(
+        this.data,
+        "wus:WalkupScanToCompSettings",
+      )
+    ) {
       return this.data["wus:WalkupScanToCompSettings"]["0"]["wus:Shortcut"][0];
     }
     return null;
   }
 
   get scanPlexMode(): string | null {
-    if (this.data.hasOwnProperty("wus:WalkupScanToCompSettings")) {
+    if (
+      Object.prototype.hasOwnProperty.call(
+        this.data,
+        "wus:WalkupScanToCompSettings",
+      )
+    ) {
       return (
         this.data["wus:WalkupScanToCompSettings"]["0"]["scantype:ScanSettings"][
           "0"

package/src/WalkupScanToCompDestinations.ts

@@ -3,7 +3,7 @@ import { Parser } from "xml2js";
 const parser = new Parser();
 import { promisify } from "util";
 const parseString = promisify<string, WalkupScanToCompDestinationsData>(
-  parser.parseString
+  parser.parseString,
 );
 
 import WalkupScanToCompDestination, {
@@ -22,7 +22,7 @@ export default class WalkupScanToCompDestinations {
     this.data = data;
   }
   static async createWalkupScanToCompDestinations(
-    content: string
+    content: string,
   ): Promise<WalkupScanToCompDestinations> {
     const parsed = await parseString(content);
     return new WalkupScanToCompDestinations(parsed);
@@ -32,8 +32,9 @@ export default class WalkupScanToCompDestinations {
     let walkupScanToCompDestinations =
       this.data["wus:WalkupScanToCompDestinations"];
     if (
-      walkupScanToCompDestinations.hasOwnProperty(
-        "wus:WalkupScanToCompDestination"
+      Object.prototype.hasOwnProperty.call(
+        walkupScanToCompDestinations,
+        "wus:WalkupScanToCompDestination",
       )
     ) {
       return walkupScanToCompDestinations[

package/src/WalkupScanToCompEvent.ts

@@ -3,7 +3,7 @@ import { Parser } from "xml2js";
 const parser = new Parser();
 import { promisify } from "util";
 const parseString = promisify<string, WalkupScanToCompEventData>(
-  parser.parseString
+  parser.parseString,
 );
 
 export interface WalkupScanToCompEventData {

package/src/WalkupScanToCompManifest.ts

@@ -3,7 +3,7 @@ import { Parser } from "xml2js";
 const parser = new Parser();
 import { promisify } from "util";
 const parseString = promisify<string, WalkupScanToCompManifestData>(
-  parser.parseString
+  parser.parseString,
 );
 
 export interface WalkupScanToCompManifestData {
@@ -31,7 +31,7 @@ export default class WalkupScanToCompManifest {
     this.data = data;
   }
   static async createWalkupScanToCompManifest(
-    content: string
+    content: string,
   ): Promise<WalkupScanToCompManifest> {
     const parsed = await parseString(content);
     return new WalkupScanToCompManifest(parsed);
@@ -43,7 +43,7 @@ export default class WalkupScanToCompManifest {
     ]["map:ResourceNode"].find(
       (x) =>
         x["map:ResourceType"][0]["wus:WalkupScanToCompResourceType"][0] ===
-        "WalkupScanToCompCaps"
+        "WalkupScanToCompCaps",
     );
 
     if (walkupScanToCompCaps === undefined) {

package/src/index.ts

@@ -11,27 +11,38 @@ import HPApi from "./HPApi";
 import PathHelper from "./PathHelper";
 import { delay } from "./delay";
 import { readDeviceCapabilities } from "./readDeviceCapabilities";
-import { clearRegistrations, RegistrationConfig, waitScanEvent } from "./listening";
-import { AdfAutoScanConfig, DirectoryConfig, saveScan, ScanConfig, scanFromAdf, waitAdfLoaded } from "./scanProcessing";
+import {
+  clearRegistrations,
+  RegistrationConfig,
+  waitScanEvent,
+} from "./listening";
+import {
+  AdfAutoScanConfig,
+  DirectoryConfig,
+  saveScan,
+  ScanConfig,
+  scanFromAdf,
+  waitAdfLoaded,
+} from "./scanProcessing";
 
 let iteration = 0;
 
 async function listenCmd(
   registrationConfig: RegistrationConfig,
   scanConfig: ScanConfig,
-  deviceUpPollingInterval: number
+  deviceUpPollingInterval: number,
 ) {
   // first make sure the device is reachable
   await HPApi.waitDeviceUp(deviceUpPollingInterval);
   let deviceUp = true;
 
   const folder = await PathHelper.getOutputFolder(
-    scanConfig.directoryConfig.directory
+    scanConfig.directoryConfig.directory,
   );
   console.log(`Target folder: ${folder}`);
 
   const tempFolder = await PathHelper.getOutputFolder(
-    scanConfig.directoryConfig.tempDirectory
+    scanConfig.directoryConfig.tempDirectory,
   );
   console.log(`Temp folder: ${tempFolder}`);
 
@@ -44,7 +55,11 @@ async function listenCmd(
     console.log(`Running iteration: ${iteration} - errorCount: ${errorCount}`);
     try {
       const event = await waitScanEvent(deviceCapabilities, registrationConfig);
-      scanCount++;
+      scanCount = await PathHelper.getNextScanNumber(
+        folder,
+        scanCount,
+        scanConfig.directoryConfig.filePattern,
+      );
       console.log(`Scan event captured, saving scan #${scanCount}`);
       await saveScan(
         event,
@@ -52,7 +67,7 @@ async function listenCmd(
         tempFolder,
         scanCount,
         deviceCapabilities,
-        scanConfig
+        scanConfig,
       );
     } catch (e) {
       console.log(e);
@@ -77,22 +92,24 @@ async function listenCmd(
 
 async function adfAutoscanCmd(
   adfAutoScanConfig: AdfAutoScanConfig,
-  deviceUpPollingInterval: number
+  deviceUpPollingInterval: number,
 ) {
   // first make sure the device is reachable
   await HPApi.waitDeviceUp(deviceUpPollingInterval);
   let deviceUp = true;
 
   const folder = await PathHelper.getOutputFolder(
-    adfAutoScanConfig.directoryConfig.directory
+    adfAutoScanConfig.directoryConfig.directory,
   );
   console.log(`Target folder: ${folder}`);
 
   const tempFolder = await PathHelper.getOutputFolder(
-    adfAutoScanConfig.directoryConfig.tempDirectory
+    adfAutoScanConfig.directoryConfig.tempDirectory,
   );
   console.log(`Temp folder: ${tempFolder}`);
 
+  const deviceCapabilities = await readDeviceCapabilities();
+
   let scanCount = 0;
   let keepActive = true;
   let errorCount = 0;
@@ -101,14 +118,21 @@ async function adfAutoscanCmd(
     try {
       await waitAdfLoaded(
         adfAutoScanConfig.pollingInterval,
-        adfAutoScanConfig.startScanDelay
+        adfAutoScanConfig.startScanDelay,
       );
 
       scanCount++;
 
       console.log(`Scan event captured, saving scan #${scanCount}`);
 
-      await scanFromAdf(scanCount, folder, tempFolder, adfAutoScanConfig);
+      await scanFromAdf(
+        scanCount,
+        folder,
+        tempFolder,
+        adfAutoScanConfig,
+        deviceCapabilities,
+        new Date()
+      );
     } catch (e) {
       console.log(e);
       if (await HPApi.isAlive()) {
@@ -162,7 +186,7 @@ function findOfficejetIp(deviceNamePrefix: string): Promise<string> {
           console.log(`Found: ${service.name}`);
           resolve(service.addresses[0]);
         }
-      }
+      },
     );
     browser.start();
   });
@@ -175,19 +199,27 @@ function getConfig<T>(name: string): T | undefined {
 function setupScanParameters(command: Command): Command {
   command.option(
     "-d, --directory <dir>",
-    "Directory where scans are saved (default: /tmp/scan-to-pc<random>)"
+    "Directory where scans are saved (default: /tmp/scan-to-pc<random>)",
   );
   command.option(
     "-t, --temp-directory <dir>",
-    "Temp directory used for processing (default: /tmp/scan-to-pc<random>)"
+    "Temp directory used for processing (default: /tmp/scan-to-pc<random>)",
   );
   command.option(
     "-p, --pattern <pattern>",
-    'Pattern for filename (i.e. "scan"_dd.mm.yyyy_hh:MM:ss, without this its scanPage<number>)'
+    'Pattern for filename (i.e. "scan"_dd.mm.yyyy_hh:MM:ss, without this its scanPage<number>)',
   );
   command.option(
     "-r, --resolution <dpi>",
-    "Resolution in DPI of the scans (default: 200)"
+    "Resolution in DPI of the scans (default: 200)",
+  );
+  command.option(
+    "-w, --width <width>",
+    "With in pixel of the scans (default: 2481)",
+  );
+  command.option(
+    "-h, --height <height>",
+    "Height in pixel of the scans (default: 3507)",
   );
   return command;
 }
@@ -195,16 +227,16 @@ function setupScanParameters(command: Command): Command {
 function setupParameterOpts(command: Command): Command {
   command.option(
     "-ip, --address <ip>",
-    "IP address of the device (this overrides -p)"
+    "IP address of the device (this overrides -p)",
   );
   command.option(
     "--device-up-polling-interval <deviceUpPollingInterval>",
     "Device up polling interval in milliseconds",
-    parseFloat
+    parseFloat,
   );
   command.option(
     "-n, --name <name>",
-    "Name of the device for service discovery"
+    "Name of the device for service discovery",
   ); // i.e. 'Deskjet 3520 series'
 
   command.option("-D, --debug", "Enable debug");
@@ -238,11 +270,33 @@ function getScanConfiguration(parentOption: OptionValues) {
     filePattern: parentOption.pattern || getConfig("pattern"),
   };
 
+  const configWidth = (
+    parentOption.width ||
+    getConfig("width") ||
+    0
+  ).toString();
+  const width =
+    configWidth.toLowerCase() === "max"
+      ? Number.MAX_SAFE_INTEGER
+      : parseInt(configWidth, 10);
+
+  const configHeight = (
+    parentOption.width ||
+    getConfig("height") ||
+    "0"
+  ).toString();
+  const height =
+    configWidth.toLowerCase() === "max"
+      ? Number.MAX_SAFE_INTEGER
+      : parseInt(configHeight, 10);
+
   const scanConfig: ScanConfig = {
     resolution: parseInt(
-      parentOption.resolution || getConfig("resolution") || 200,
-      10
+      parentOption.resolution || getConfig("resolution") || "200",
+      10,
     ),
+    width: width,
+    height: height,
     directoryConfig,
   };
   return scanConfig;
@@ -256,7 +310,6 @@ function getDeviceUpPollingInterval(parentOption: OptionValues) {
   );
 }
 
-
 async function main() {
   setupParameterOpts(program);
   const cmdListen = program.createCommand("listen");
@@ -264,7 +317,7 @@ async function main() {
     .description("Listen the device for new scan job to save to this target")
     .option(
       "-l, --label <label>",
-      "The label to display on the device (the default is the hostname)"
+      "The label to display on the device (the default is the hostname)",
     )
     .action(async (options, cmd) => {
       const parentOption = cmd.parent.opts();
@@ -290,31 +343,31 @@ async function main() {
   const cmdAdfAutoscan = program.createCommand("adf-autoscan");
   setupScanParameters(cmdAdfAutoscan)
     .addOption(
-      new Option("--duplex", "If specified, the scan will be in duplex")
+      new Option("--duplex", "If specified, the scan will be in duplex"),
     )
     .addOption(
       new Option(
         "--pdf",
-        "If specified, the scan result will be a pdf document, the default is multiple jpeg files"
-      )
+        "If specified, the scan result will be a pdf document, the default is multiple jpeg files",
+      ),
     )
     .addOption(
       new Option(
         "--pollingInterval <pollingInterval>",
         "Time interval in millisecond between each lookup for content in the automatic document feeder",
-      )
+      ),
     )
     .description(
-      "Automatically trigger a new scan job to this target once paper is detected in the automatic document feeder (adf)"
+      "Automatically trigger a new scan job to this target once paper is detected in the automatic document feeder (adf)",
     )
     .addOption(
       new Option(
         "--start-scan-delay <startScanDelay>",
         "Once document are detected to be in the adf, this specify the wait delay in millisecond before triggering the scan",
-      )
+      ),
     )
     .description(
-      "Automatically trigger a new scan job to this target once paper is detected in the automatic document feeder (adf)"
+      "Automatically trigger a new scan job to this target once paper is detected in the automatic document feeder (adf)",
     )
     .action(async (options, cmd) => {
       const parentOption = cmd.parent.opts();
@@ -334,9 +387,13 @@ async function main() {
         isDuplex: options.isDuplex || getConfig("autoscan_duplex") || false,
         generatePdf: options.pdf || getConfig("autoscan_pdf") || false,
         pollingInterval:
-          options.pollingInterval || getConfig("autoscan_pollingInterval") || 1000,
+          options.pollingInterval ||
+          getConfig("autoscan_pollingInterval") ||
+          1000,
         startScanDelay:
-          options.startScanDelay || getConfig("autoscan_startScanDelay") || 5000,
+          options.startScanDelay ||
+          getConfig("autoscan_startScanDelay") ||
+          5000,
       };
 
       await adfAutoscanCmd(adfScanConfig, deviceUpPollingInterval);

package/src/listening.ts

@@ -6,9 +6,8 @@ import { DeviceCapabilities } from "./DeviceCapabilities";
 export async function waitScanRequest(compEventURI: string): Promise<boolean> {
   const waitMax = 50;
   for (let i = 0; i < waitMax; i++) {
-    let walkupScanToCompEvent = await HPApi.getWalkupScanToCompEvent(
-      compEventURI
-    );
+    let walkupScanToCompEvent =
+      await HPApi.getWalkupScanToCompEvent(compEventURI);
     let message = walkupScanToCompEvent.eventType;
     if (message === "HostSelected") {
       // this ok to wait
@@ -32,7 +31,7 @@ export async function waitScanRequest(compEventURI: string): Promise<boolean> {
 
 export async function waitForScanEvent(
   resourceURI: string,
-  afterEtag: string | null = null
+  afterEtag: string | null = null,
 ): Promise<Event> {
   console.log("Start listening for new ScanEvent");
 
@@ -47,21 +46,21 @@ export async function waitForScanEvent(
       (ev) =>
         ev.isScanEvent &&
         ev.destinationURI &&
-        ev.destinationURI.indexOf(resourceURI) >= 0
+        ev.destinationURI.indexOf(resourceURI) >= 0,
     );
   }
   return acceptedScanEvent;
 }
 
 async function registerWalkupScanToCompDestination(
-  registrationConfig: RegistrationConfig
+  registrationConfig: RegistrationConfig,
 ): Promise<string> {
   const walkupScanDestinations = await HPApi.getWalkupScanToCompDestinations();
   const destinations = walkupScanDestinations.destinations;
 
   console.log(
     "Host destinations fetched:",
-    destinations.map((d) => d.name).join(", ")
+    destinations.map((d) => d.name).join(", "),
   );
 
   const hostname = registrationConfig.label;
@@ -70,12 +69,12 @@ async function registerWalkupScanToCompDestination(
   let resourceURI;
   if (destination) {
     console.log(
-      `Re-using existing destination: ${hostname} - ${destination.resourceURI}`
+      `Re-using existing destination: ${hostname} - ${destination.resourceURI}`,
     );
     resourceURI = destination.resourceURI;
   } else {
     resourceURI = await HPApi.registerWalkupScanToCompDestination(
-      new Destination(hostname, hostname, true)
+      new Destination(hostname, hostname, true),
     );
     console.log(`New Destination registered: ${hostname} - ${resourceURI}`);
   }
@@ -86,14 +85,14 @@ async function registerWalkupScanToCompDestination(
 }
 
 async function registerWalkupScanDestination(
-  registrationConfig: RegistrationConfig
+  registrationConfig: RegistrationConfig,
 ): Promise<string> {
   const walkupScanDestinations = await HPApi.getWalkupScanDestinations();
   const destinations = walkupScanDestinations.destinations;
 
   console.log(
     "Host destinations fetched:",
-    destinations.map((d) => d.name).join(", ")
+    destinations.map((d) => d.name).join(", "),
   );
 
   const hostname = registrationConfig.label;
@@ -102,12 +101,12 @@ async function registerWalkupScanDestination(
   let resourceURI;
   if (destination) {
     console.log(
-      `Re-using existing destination: ${hostname} - ${destination.resourceURI}`
+      `Re-using existing destination: ${hostname} - ${destination.resourceURI}`,
     );
     resourceURI = destination.resourceURI;
   } else {
     resourceURI = await HPApi.registerWalkupScanDestination(
-      new Destination(hostname, hostname, false)
+      new Destination(hostname, hostname, false),
     );
     console.log(`New Destination registered: ${hostname} - ${resourceURI}`);
   }
@@ -123,7 +122,7 @@ export type RegistrationConfig = {
 
 export async function waitScanEvent(
   deviceCapabilities: DeviceCapabilities,
-  registrationConfig: RegistrationConfig
+  registrationConfig: RegistrationConfig,
 ): Promise<Event> {
   let resourceURI: string;
   if (deviceCapabilities.useWalkupScanToComp) {
@@ -142,4 +141,4 @@ export async function clearRegistrations() {
     console.log(`Removing: ${dests.destinations[i].name}`);
     await HPApi.removeDestination(dests.destinations[i]);
   }
-}
+}