node-hp-scan-to 1.3.0 → 1.4.0

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]);
   }
-}
+}

package/src/readDeviceCapabilities.ts

@@ -1,6 +1,7 @@
 import { DeviceCapabilities } from "./DeviceCapabilities";
 import HPApi from "./HPApi";
 import WalkupScanToCompCaps from "./WalkupScanToCompCaps";
+import ScanCaps from "./ScanCaps";
 
 export async function readDeviceCapabilities(): Promise<DeviceCapabilities> {
   let supportsMultiItemScanFromPlaten = true;
@@ -8,39 +9,44 @@ export async function readDeviceCapabilities(): Promise<DeviceCapabilities> {
   let walkupScanToCompCaps: WalkupScanToCompCaps | null = null;
   if (discoveryTree.WalkupScanToCompManifestURI != null) {
     const walkupScanToCompManifest = await HPApi.getWalkupScanToCompManifest(
-      discoveryTree.WalkupScanToCompManifestURI
+      discoveryTree.WalkupScanToCompManifestURI,
     );
     if (walkupScanToCompManifest.WalkupScanToCompCapsURI != null) {
       walkupScanToCompCaps = await HPApi.getWalkupScanToCompCaps(
-        walkupScanToCompManifest.WalkupScanToCompCapsURI
+        walkupScanToCompManifest.WalkupScanToCompCapsURI,
       );
       supportsMultiItemScanFromPlaten =
         walkupScanToCompCaps.supportsMultiItemScanFromPlaten;
     }
   } else if (discoveryTree.WalkupScanManifestURI != null) {
     const walkupScanManifest = await HPApi.getWalkupScanManifest(
-      discoveryTree.WalkupScanManifestURI
+      discoveryTree.WalkupScanManifestURI,
     );
     if (walkupScanManifest.walkupScanDestinationsURI != null) {
       await HPApi.getWalkupScanDestinations(
-        walkupScanManifest.walkupScanDestinationsURI
+        walkupScanManifest.walkupScanDestinationsURI,
       );
     }
   } else {
     console.log("Unknown device!");
   }
 
+  let scanCaps: ScanCaps | null = null;
   if (discoveryTree.ScanJobManifestURI != null) {
     const scanJobManifest = await HPApi.getScanJobManifest(
-      discoveryTree.ScanJobManifestURI
+      discoveryTree.ScanJobManifestURI,
     );
     if (scanJobManifest.ScanCapsURI != null) {
-      await HPApi.getScanCaps(scanJobManifest.ScanCapsURI);
+      scanCaps = await HPApi.getScanCaps(scanJobManifest.ScanCapsURI);
     }
   }
 
   return {
     supportsMultiItemScanFromPlaten,
     useWalkupScanToComp: walkupScanToCompCaps != null,
+    platenMaxWidth: scanCaps?.PlatenMaxWidth || null,
+    platenMaxHeight: scanCaps?.PlatenMaxHeight || null,
+    adfMaxWidth: scanCaps?.AdfMaxWidth || null,
+    adfMaxHeight: scanCaps?.AdfMaxHeight || null,
   };
 }

package/src/scanProcessing.ts

@@ -12,9 +12,10 @@ import Job from "./Job";
 import { delay } from "./delay";
 import PathHelper from "./PathHelper";
 import ScanStatus from "./ScanStatus";
+import { InputSource } from "./InputSource";
 
 async function waitDeviceUntilItIsReadyToUploadOrCompleted(
-  jobUrl: string
+  jobUrl: string,
 ): Promise<Job> {
   let job = null;
   let isReadyToUpload = false;
@@ -38,7 +39,7 @@ async function waitDeviceUntilItIsReadyToUploadOrCompleted(
 }
 
 async function TryGetDestination(
-  event: Event
+  event: Event,
 ): Promise<WalkupScanDestination | WalkupScanToCompDestination | null> {
   //this code can in some cases be executed before the user actually chooses between Document or Photo
   //so lets fetch the contentType (Document or Photo) until we get a value
@@ -83,7 +84,7 @@ function createScanPage(
   job: Job,
   currentPageNumber: number,
   filePath: string,
-  sizeFixed: number | null
+  sizeFixed: number | null,
 ): ScanPage {
   let height = sizeFixed ?? job.imageHeight;
   return {
@@ -92,17 +93,18 @@ function createScanPage(
     width: job.imageWidth ?? 0,
     height: height ?? 0,
     xResolution: job.xResolution ?? 200,
-    yResolution: job.yResolution ?? 200
+    yResolution: job.yResolution ?? 200,
   };
 }
 
 async function handleProcessingState(
   job: Job,
-  inputSource: "Adf" | "Platen",
+  inputSource: InputSource,
   folder: string,
   scanCount: number,
   currentPageNumber: number,
-  filePattern: string | undefined
+  filePattern: string | undefined,
+  date: Date,
 ): Promise<ScanPage | null> {
   if (
     job.pageState == "ReadyToUpload" &&
@@ -111,7 +113,7 @@ async function handleProcessingState(
   ) {
     console.log(
       `Ready to download page job page ${job.currentPageNumber} at:`,
-      job.binaryURL
+      job.binaryURL,
     );
 
     const destinationFilePath = PathHelper.getFileForPage(
@@ -119,20 +121,21 @@ async function handleProcessingState(
       scanCount,
       currentPageNumber,
       filePattern,
-      "jpg"
+      "jpg",
+      date,
     );
     const filePath = await HPApi.downloadPage(
       job.binaryURL,
-      destinationFilePath
+      destinationFilePath,
     );
     console.log("Page downloaded to:", filePath);
 
     let sizeFixed: null | number = null;
-    if (inputSource == "Adf") {
+    if (inputSource == InputSource.Adf) {
       sizeFixed = await scanProcessing(filePath);
       if (sizeFixed == null) {
         console.log(
-          `File size has not been fixed, DNF may not have been found and approximate height is: ${job.imageHeight}`
+          `File size has not been fixed, DNF may not have been found and approximate height is: ${job.imageHeight}`,
         );
       }
     }
@@ -146,11 +149,12 @@ async function handleProcessingState(
 
 async function executeScanJob(
   scanJobSettings: ScanJobSettings,
-  inputSource: "Adf" | "Platen",
+  inputSource: InputSource,
   folder: string,
   scanCount: number,
   scanJobContent: ScanContent,
-  filePattern: string | undefined
+  filePattern: string | undefined,
+  date: Date,
 ): Promise<"Completed" | "Canceled"> {
   const jobUrl = await HPApi.postJob(scanJobSettings);
 
@@ -171,7 +175,8 @@ async function executeScanJob(
         folder,
         scanCount,
         scanJobContent.elements.length + 1,
-        filePattern
+        filePattern,
+        date,
       );
       job = await HPApi.getJob(jobUrl);
       if (page != null && job.jobState != "Canceled") {
@@ -186,7 +191,7 @@ async function executeScanJob(
     }
   }
   console.log(
-    `Job state: ${job.jobState}, totalPages: ${scanJobContent.elements.length}:`
+    `Job state: ${job.jobState}, totalPages: ${scanJobContent.elements.length}:`,
   );
   return job.jobState;
 }
@@ -197,9 +202,8 @@ async function waitScanNewPageRequest(compEventURI: string): Promise<boolean> {
   while (wait) {
     await new Promise((resolve) => setTimeout(resolve, 1000)); //wait 1s
 
-    let walkupScanToCompEvent = await HPApi.getWalkupScanToCompEvent(
-      compEventURI
-    );
+    let walkupScanToCompEvent =
+      await HPApi.getWalkupScanToCompEvent(compEventURI);
     let message = walkupScanToCompEvent.eventType;
 
     if (message === "ScanNewPageRequested") {
@@ -219,13 +223,14 @@ async function waitScanNewPageRequest(compEventURI: string): Promise<boolean> {
 
 async function executeScanJobs(
   scanJobSettings: ScanJobSettings,
-  inputSource: "Adf" | "Platen",
+  inputSource: InputSource,
   folder: string,
   scanCount: number,
   scanJobContent: ScanContent,
   firstEvent: Event,
   deviceCapabilities: DeviceCapabilities,
-  filePattern: string | undefined
+  filePattern: string | undefined,
+  date: Date,
 ) {
   let jobState = await executeScanJob(
     scanJobSettings,
@@ -233,19 +238,20 @@ async function executeScanJobs(
     folder,
     scanCount,
     scanJobContent,
-    filePattern
+    filePattern,
+    date,
   );
   let lastEvent = firstEvent;
   if (
     jobState === "Completed" &&
     lastEvent.compEventURI &&
-    inputSource !== "Adf" &&
+    inputSource !== InputSource.Adf &&
     lastEvent.destinationURI &&
     deviceCapabilities.supportsMultiItemScanFromPlaten
   ) {
     lastEvent = await waitForScanEvent(
       lastEvent.destinationURI,
-      lastEvent.agingStamp
+      lastEvent.agingStamp,
     );
     if (!lastEvent.compEventURI) {
       return;
@@ -258,7 +264,8 @@ async function executeScanJobs(
         folder,
         scanCount,
         scanJobContent,
-        filePattern
+        filePattern,
+        new Date(),
       );
       if (jobState !== "Completed") {
         return;
@@ -268,7 +275,7 @@ async function executeScanJobs(
       }
       lastEvent = await waitForScanEvent(
         lastEvent.destinationURI,
-        lastEvent.agingStamp
+        lastEvent.agingStamp,
       );
       if (!lastEvent.compEventURI) {
         return;
@@ -282,14 +289,16 @@ async function mergeToPdf(
   folder: string,
   scanCount: number,
   scanJobContent: ScanContent,
-  filePattern: string | undefined
+  filePattern: string | undefined,
+  date: Date,
 ): Promise<string | null> {
   if (scanJobContent.elements.length > 0) {
-    const pdfFilePath = PathHelper.getFileForScan(
+    const pdfFilePath: string = PathHelper.getFileForScan(
       folder,
       scanCount,
       filePattern,
-      "pdf"
+      "pdf",
+      date,
     );
     await createPdfFrom(scanJobContent, pdfFilePath);
     scanJobContent.elements.forEach((e) => fs.unlink(e.path));
@@ -301,21 +310,21 @@ async function mergeToPdf(
 
 function displayPdfScan(
   pdfFilePath: string | null,
-  scanJobContent: ScanContent
+  scanJobContent: ScanContent,
 ) {
   if (pdfFilePath === null) {
     console.log(`Pdf generated has not been generated`);
     return;
   }
   console.log(
-    `The following page(s) have been rendered inside '${pdfFilePath}': `
+    `The following page(s) have been rendered inside '${pdfFilePath}': `,
   );
   scanJobContent.elements.forEach((e) =>
     console.log(
       `\t- page ${e.pageNumber.toString().padStart(3, " ")} - ${e.width}x${
         e.height
-      }`
-    )
+      }`,
+    ),
   );
 }
 
@@ -324,13 +333,13 @@ function displayJpegScan(scanJobContent: ScanContent) {
     console.log(
       `\t- page ${e.pageNumber.toString().padStart(3, " ")} - ${e.width}x${
         e.height
-      } - ${e.path}`
-    )
+      } - ${e.path}`,
+    ),
   );
 }
 
 function isPdf(
-  destination: WalkupScanDestination | WalkupScanToCompDestination
+  destination: WalkupScanDestination | WalkupScanToCompDestination,
 ) {
   if (
     destination.shortcut === "SavePDF" ||
@@ -345,19 +354,61 @@ function isPdf(
     return false;
   } else {
     console.log(
-      `Unexpected shortcut received: ${destination.shortcut}, considering it as non pdf target!`
+      `Unexpected shortcut received: ${destination.shortcut}, considering it as non pdf target!`,
     );
     return false;
   }
 }
 
+export function getScanWidth(
+  scanConfig: ScanConfig,
+  inputSource: "Adf" | "Platen",
+  deviceCapabilities: DeviceCapabilities,
+) {
+  if (scanConfig.width && scanConfig.width > 0) {
+    const maxWidth =
+      inputSource === "Adf"
+        ? deviceCapabilities.adfMaxWidth
+        : deviceCapabilities.platenMaxWidth;
+
+    if (maxWidth && scanConfig.width > maxWidth) {
+      return maxWidth;
+    } else {
+      return scanConfig.width;
+    }
+  } else {
+    return null;
+  }
+}
+
+export function getScanHeight(
+  scanConfig: ScanConfig,
+  inputSource: "Adf" | "Platen",
+  deviceCapabilities: DeviceCapabilities,
+) {
+  if (scanConfig.height && scanConfig.height > 0) {
+    const maxHeight =
+      inputSource === "Adf"
+        ? deviceCapabilities.adfMaxHeight
+        : deviceCapabilities.platenMaxHeight;
+
+    if (maxHeight && scanConfig.height > maxHeight) {
+      return maxHeight;
+    } else {
+      return scanConfig.height;
+    }
+  } else {
+    return null;
+  }
+}
+
 export async function saveScan(
   event: Event,
   folder: string,
   tempFolder: string,
   scanCount: number,
   deviceCapabilities: DeviceCapabilities,
-  scanConfig: ScanConfig
+  scanConfig: ScanConfig,
 ): Promise<void> {
   if (event.compEventURI) {
     const proceedToScan = await waitScanRequest(event.compEventURI);
@@ -381,7 +432,7 @@ export async function saveScan(
     contentType = "Document";
     destinationFolder = tempFolder;
     console.log(
-      `Scan will be converted to pdf, using ${destinationFolder} as temp scan output directory for individual pages`
+      `Scan will be converted to pdf, using ${destinationFolder} as temp scan output directory for individual pages`,
     );
   } else {
     toPdf = false;
@@ -397,16 +448,22 @@ export async function saveScan(
   console.log("Afd is : " + scanStatus.adfState);
 
   const inputSource = scanStatus.getInputSource();
+  const scanWidth = getScanWidth(scanConfig, inputSource, deviceCapabilities);
+  const scanHeight = getScanHeight(scanConfig, inputSource, deviceCapabilities);
 
   const scanJobSettings = new ScanJobSettings(
     inputSource,
     contentType,
     scanConfig.resolution,
-    isDuplex
+    scanWidth,
+    scanHeight,
+    isDuplex,
   );
 
   const scanJobContent: ScanContent = { elements: [] };
 
+  const scanDate = new Date();
+
   await executeScanJobs(
     scanJobSettings,
     inputSource,
@@ -415,11 +472,12 @@ export async function saveScan(
     scanJobContent,
     event,
     deviceCapabilities,
-    scanConfig.directoryConfig.filePattern
+    scanConfig.directoryConfig.filePattern,
+    scanDate,
   );
 
   console.log(
-    `Scan of page(s) completed totalPages: ${scanJobContent.elements.length}:`
+    `Scan of page(s) completed totalPages: ${scanJobContent.elements.length}:`,
   );
 
   if (toPdf) {
@@ -427,7 +485,8 @@ export async function saveScan(
       folder,
       scanCount,
       scanJobContent,
-      scanConfig.directoryConfig.filePattern
+      scanConfig.directoryConfig.filePattern,
+      scanDate,
     );
     displayPdfScan(pdfFilePath, scanJobContent);
   } else {
@@ -442,6 +501,8 @@ export type DirectoryConfig = {
 };
 export type ScanConfig = {
   resolution: number;
+  width: number | null;
+  height: number | null;
   directoryConfig: DirectoryConfig;
 };
 export type AdfAutoScanConfig = ScanConfig & {
@@ -455,7 +516,9 @@ export async function scanFromAdf(
   scanCount: number,
   folder: string,
   tempFolder: string,
-  adfAutoScanConfig: AdfAutoScanConfig
+  adfAutoScanConfig: AdfAutoScanConfig,
+  deviceCapabilities: DeviceCapabilities,
+  date: Date,
 ) {
   let destinationFolder: string;
   let contentType: "Document" | "Photo";
@@ -463,33 +526,43 @@ export async function scanFromAdf(
     contentType = "Document";
     destinationFolder = tempFolder;
     console.log(
-      `Scan will be converted to pdf, using ${destinationFolder} as temp scan output directory for individual pages`
+      `Scan will be converted to pdf, using ${destinationFolder} as temp scan output directory for individual pages`,
     );
   } else {
     contentType = "Photo";
     destinationFolder = folder;
   }
 
-  const scanJobSettings = new ScanJobSettings(
+  const scanWidth = getScanWidth(adfAutoScanConfig, "Adf", deviceCapabilities);
+  const scanHeight = getScanHeight(
+    adfAutoScanConfig,
     "Adf",
+    deviceCapabilities,
+  );
+
+  const scanJobSettings = new ScanJobSettings(
+    InputSource.Adf,
     contentType,
     adfAutoScanConfig.resolution,
-    adfAutoScanConfig.isDuplex
+    scanWidth,
+    scanHeight,
+    adfAutoScanConfig.isDuplex,
   );
 
   const scanJobContent: ScanContent = { elements: [] };
 
   await executeScanJob(
     scanJobSettings,
-    "Adf",
+    InputSource.Adf,
     destinationFolder,
     scanCount,
     scanJobContent,
-    adfAutoScanConfig.directoryConfig.filePattern
+    adfAutoScanConfig.directoryConfig.filePattern,
+    date,
   );
 
   console.log(
-    `Scan of page(s) completed totalPages: ${scanJobContent.elements.length}:`
+    `Scan of page(s) completed, total pages: ${scanJobContent.elements.length}:`,
   );
 
   if (adfAutoScanConfig.generatePdf) {
@@ -497,7 +570,8 @@ export async function scanFromAdf(
       folder,
       scanCount,
       scanJobContent,
-      adfAutoScanConfig.directoryConfig.filePattern
+      adfAutoScanConfig.directoryConfig.filePattern,
+      date,
     );
     displayPdfScan(pdfFilePath, scanJobContent);
   } else {
@@ -505,7 +579,10 @@ export async function scanFromAdf(
   }
 }
 
-export async function waitAdfLoaded(pollingInterval: number, startScanDelay: number) {
+export async function waitAdfLoaded(
+  pollingInterval: number,
+  startScanDelay: number,
+) {
   let ready = false;
   while (!ready) {
     let scanStatus: ScanStatus = await HPApi.getScanStatus();
@@ -532,4 +609,4 @@ export async function waitAdfLoaded(pollingInterval: number, startScanDelay: num
       console.log(`ADF not loaded anymore, waiting...`);
     }
   }
-}
+}

package/dist/fixJpegSize.d.ts

@@ -1,19 +0,0 @@
-import Event from "./Event";
-import { DeviceCapabilities } from "./DeviceCapabilities";
-export declare function saveScan(event: Event, folder: string, tempFolder: string, scanCount: number, deviceCapabilities: DeviceCapabilities, scanConfig: ScanConfig): Promise<void>;
-export type DirectoryConfig = {
-    directory: string | undefined;
-    tempDirectory: string | undefined;
-    filePattern: string | undefined;
-};
-export type ScanConfig = {
-    resolution: number;
-    directoryConfig: DirectoryConfig;
-};
-export type AdfAutoScanConfig = ScanConfig & {
-    isDuplex: boolean;
-    generatePdf: boolean;
-    pollingInterval: number;
-    startScanDelay: number;
-};
-export declare function scanFromAdf(scanCount: number, folder: string, tempFolder: string, adfAutoScanConfig: AdfAutoScanConfig): Promise<void>;