node-hp-scan-to 1.2.1 → 1.3.0

package/src/KnownShortcut.ts

@@ -0,0 +1,6 @@
+export type KnownShortcut =
+  | "SaveDocument1"
+  | "SavePDF"
+  | "EmailPDF"
+  | "SavePhoto1"
+  | "SaveJPEG";

package/src/PathHelper.ts

@@ -1,6 +1,7 @@
 import path from "path";
 import dateformat from "dateformat";
-import fs from "fs/promises";
+const { promises: Fs } = require("fs");
+const fs = require("fs");
 import os from "os";
 
 export default class PathHelper {
@@ -8,36 +9,69 @@ export default class PathHelper {
     folder: string,
     scanCount: number,
     currentPageNumber: number,
-    filePattern : string | undefined,
+    filePattern: string | undefined,
     extension: string
   ): string {
-
     if (filePattern) {
-      return path.join(folder, `${dateformat(new Date(), filePattern)}.${extension}`);
+      return path.join(
+        folder,
+        `${dateformat(new Date(), filePattern)}.${extension}`
+      );
+    }
+
+    return path.join(
+      folder,
+      `scan${scanCount}_page${currentPageNumber}.${extension}`
+    );
+  }
+
+  static makeUnique(filePath: string): string {
+    if (!fs.existsSync(filePath)) {
+      return filePath;
     }
 
-    return path.join(folder, `scan${scanCount}_page${currentPageNumber}.${extension}`);
+    let parsed = path.parse(filePath);
+    let tryName = `${parsed.dir}${path.sep}${parsed.name}${dateformat(
+      new Date(),
+      "yyyymmdd"
+    )}${parsed.ext}`;
+    if (!fs.existsSync(tryName)) {
+      return tryName;
+    }
+
+    parsed = path.parse(tryName);
+    let i = "a";
+    while (i <= "z") {
+      tryName = `${parsed.dir}${path.sep}${parsed.name}_${i}${parsed.ext}`;
+      if (!fs.existsSync(tryName)) {
+        return tryName;
+      }
+      i = String.fromCharCode(i.charCodeAt(0) + 1);
+    }
+    throw new Error(
+      `Can not create unique file: ${filePath} iterated until: ${tryName}`
+    );
   }
 
   static getFileForScan(
     folder: string,
     scanCount: number,
-    filePattern : string | undefined,
+    filePattern: string | undefined,
     extension: string
   ): string {
-
     if (filePattern) {
-      return path.join(folder, `${dateformat(new Date(), filePattern)}.${extension}`);
+      return path.join(
+        folder,
+        `${dateformat(new Date(), filePattern)}.${extension}`
+      );
     }
 
     return path.join(folder, `scan${scanCount}.${extension}`);
   }
 
-  static async getOutputFolder(folder: string | undefined) {
-    if (!folder) {
-      folder = await fs.mkdtemp(
-        path.join(os.tmpdir(), "scan-to-pc")
-      );
+  static async getOutputFolder(folder?: string | undefined): Promise<string> {
+    if (typeof folder !== "string") {
+      return Fs.mkdtemp(path.join(os.tmpdir(), "scan-to-pc"));
     }
     return folder;
   }

package/src/ScanCaps.ts

@@ -0,0 +1,19 @@
+"use strict";
+import { Parser } from "xml2js";
+const parser = new Parser();
+import { promisify } from "util";
+const parseString = promisify<string, ScanCapsData>(parser.parseString);
+export interface ScanCapsData {}
+
+export default class ScanCaps {
+  private readonly data: ScanCapsData;
+
+  constructor(data: ScanCapsData) {
+    this.data = data;
+  }
+
+  static async createScanCaps(content: string): Promise<ScanCaps> {
+    const parsed = await parseString(content);
+    return new ScanCaps(parsed);
+  }
+}

package/src/ScanContent.ts

@@ -14,7 +14,10 @@ export interface ScanPage {
   yResolution: number;
 }
 
-export async function createPdfFrom(scanContent: ScanContent, destination: string) {
+export async function createPdfFrom(
+  scanContent: ScanContent,
+  destination: string
+) {
   let doc: jsPDF | null = null;
   for (const element of scanContent.elements) {
     const widthInInches = element.width / element.xResolution;

package/src/ScanJobManifest.ts

@@ -0,0 +1,55 @@
+"use strict";
+import { Parser } from "xml2js";
+const parser = new Parser();
+import { promisify } from "util";
+const parseString = promisify<string, ScanJobManifestData>(parser.parseString);
+
+export interface ScanJobManifestData {
+  "man:Manifest": {
+    "map:ResourceMap": {
+      "map:ResourceLink": {
+        "dd:ResourceURI": string[];
+      }[];
+      "map:ResourceNode": {
+        "map:ResourceLink": {
+          "dd:ResourceURI": string[];
+        }[];
+        "map:ResourceType": {
+          "scan:ScanResourceType": string[];
+        }[];
+      }[];
+    }[];
+  };
+}
+
+export default class ScanJobManifest {
+  private readonly data: ScanJobManifestData;
+
+  constructor(data: ScanJobManifestData) {
+    this.data = data;
+  }
+  static async createScanJobManifest(
+    content: string
+  ): Promise<ScanJobManifest> {
+    const parsed = await parseString(content);
+    return new ScanJobManifest(parsed);
+  }
+
+  get ScanCapsURI(): string | null {
+    const scanCaps = this.data["man:Manifest"]["map:ResourceMap"]["0"][
+      "map:ResourceNode"
+    ].find(
+      (x) => x["map:ResourceType"][0]["scan:ScanResourceType"][0] === "ScanCaps"
+    );
+
+    if (scanCaps === undefined) {
+      return null;
+    }
+
+    return (
+      this.data["man:Manifest"]["map:ResourceMap"]["0"]["map:ResourceLink"][0][
+        "dd:ResourceURI"
+      ][0] + scanCaps["map:ResourceLink"][0]["dd:ResourceURI"][0]
+    );
+  }
+}

package/src/ScanJobSettings.ts

@@ -3,12 +3,21 @@ const parser = new xml2js.Parser();
 const util = require("util");
 
 export default class ScanJobSettings {
-  private readonly inputSource: string;
-  private readonly contentType: string;
+  private readonly inputSource: "Adf" | "Platen";
+  private readonly contentType: "Document" | "Photo";
+  private readonly resolution: number;
+  private readonly isDuplex: boolean;
 
-  constructor(inputSource: string, contentType: string) {
+  constructor(
+    inputSource: "Adf" | "Platen",
+    contentType: "Document" | "Photo",
+    resolution: number,
+    isDuplex: boolean
+  ) {
     this.inputSource = inputSource;
     this.contentType = contentType;
+    this.resolution = resolution;
+    this.isDuplex = isDuplex;
   }
 
   async toXML(): Promise<string> {
@@ -42,7 +51,13 @@ export default class ScanJobSettings {
 
     const parsed = await util.promisify(parser.parseString)(rawJob);
 
+    parsed.ScanSettings.XResolution[0] = this.resolution;
+    parsed.ScanSettings.YResolution[0] = this.resolution;
+
     parsed.ScanSettings.InputSource[0] = this.inputSource;
+    if (this.inputSource === "Adf" && this.isDuplex) {
+      parsed.ScanSettings["AdfOptions"] = [{ AdfOption: ["Duplex"] }];
+    }
     parsed.ScanSettings.ContentType[0] = this.contentType;
 
     let builder = new xml2js.Builder({

package/src/ScanStatus.ts

@@ -1,4 +1,8 @@
 "use strict";
+import { Parser } from "xml2js";
+const parser = new Parser();
+import { promisify } from "util";
+const parseString = promisify<string, ScanStatusData>(parser.parseString);
 
 export interface ScanStatusData {
   ScanStatus: {
@@ -13,6 +17,11 @@ export default class ScanStatus {
     this.data = data;
   }
 
+  static async createScanStatus(content: string): Promise<ScanStatus> {
+    const parsed = await parseString(content);
+    return new ScanStatus(parsed);
+  }
+
   get scannerState(): string {
     return this.data["ScanStatus"].ScannerState["0"];
   }

package/src/WalkupScanDestination.ts

@@ -1,19 +1,29 @@
 "use strict";
+import { Parser } from "xml2js";
+import { promisify } from "util";
+import { KnownShortcut } from "./KnownShortcut";
+
+const parser = new Parser();
+const parseString = promisify<string, WalkupScanDestinationsData>(
+  parser.parseString
+);
+
+interface WalkupScanDestinationsData {
+  "wus:WalkupScanDestinations": {
+    "wus:WalkupScanDestination": WalkupScanDestinationData[];
+  };
+}
 
 export interface WalkupScanDestinationData {
   "dd:Name": string[];
+  "dd3:Hostname": string[];
   "dd:ResourceURI": string[];
-  "wus:WalkupScanDestinations": {
-    "wus:WalkupScanDestination": {
-      "0": {
-        "wus:WalkupScanSettings": {
-          "0": {
-            "wus:Shortcut": string[];
-          };
-        };
-      };
-    };
-  };
+  "wus:WalkupScanSettings": {
+    "scantype:ScanSettings": {
+      "dd:ScanPlexMode": string[];
+    }[];
+    "wus:Shortcut": KnownShortcut[];
+  }[];
 }
 
 export default class WalkupScanDestination {
@@ -21,26 +31,40 @@ export default class WalkupScanDestination {
   constructor(data: WalkupScanDestinationData) {
     this.data = data;
   }
+  static async createWalkupScanDestination(
+    content: string
+  ): Promise<WalkupScanDestination> {
+    const parsed = await parseString(content);
+    return new WalkupScanDestination(
+      parsed["wus:WalkupScanDestinations"]["wus:WalkupScanDestination"][0]
+    );
+  }
 
   get name(): string {
     return this.data["dd:Name"][0];
   }
 
   get hostname(): string {
-    return this.data["dd:ResourceURI"][0];
+    return this.data["dd3:Hostname"][0];
   }
 
   get resourceURI(): string {
     return this.data["dd:ResourceURI"][0];
   }
 
-  get shortcut(): string {
-    return this.data["wus:WalkupScanDestinations"]["wus:WalkupScanDestination"][
-      "0"
-    ]["wus:WalkupScanSettings"]["0"]["wus:Shortcut"][0];
+  get shortcut(): null | KnownShortcut {
+    if (this.data.hasOwnProperty("wus:WalkupScanSettings")) {
+      return this.data["wus:WalkupScanSettings"]["0"]["wus:Shortcut"][0];
+    }
+    return null;
   }
 
-  getContentType(): string {
-    return this.shortcut === "SavePDF" ? "Document" : "Photo";
+  get scanPlexMode(): string | null {
+    if (this.data.hasOwnProperty("wus:WalkupScanSettings")) {
+      return this.data["wus:WalkupScanSettings"]["0"][
+        "scantype:ScanSettings"
+      ][0]["dd:ScanPlexMode"][0];
+    }
+    return null;
   }
 }

package/src/WalkupScanDestinations.ts

@@ -1,4 +1,10 @@
 "use strict";
+import { Parser } from "xml2js";
+const parser = new Parser();
+import { promisify } from "util";
+const parseString = promisify<string, WalkupScanDestinationsData>(
+  parser.parseString
+);
 
 import WalkupScanDestination, {
   WalkupScanDestinationData,
@@ -15,6 +21,12 @@ export default class WalkupScanDestinations {
   constructor(data: WalkupScanDestinationsData) {
     this.data = data;
   }
+  static async createWalkupScanDestinations(
+    content: string
+  ): Promise<WalkupScanDestinations> {
+    const parsed = await parseString(content);
+    return new WalkupScanDestinations(parsed);
+  }
 
   get destinations(): WalkupScanDestination[] {
     let walkupScanDestinations = this.data["wus:WalkupScanDestinations"];

package/src/WalkupScanManifest.ts

@@ -0,0 +1,59 @@
+"use strict";
+import { Parser } from "xml2js";
+const parser = new Parser();
+import { promisify } from "util";
+const parseString = promisify<string, WalkupScanManifestData>(
+  parser.parseString
+);
+
+export interface WalkupScanManifestData {
+  "man:Manifest": {
+    "map:ResourceMap": {
+      "map:ResourceLink": {
+        "dd:ResourceURI": string[];
+      }[];
+      "map:ResourceNode": {
+        "map:ResourceLink": {
+          "dd:ResourceURI": string[];
+        }[];
+        "map:ResourceType": {
+          "wus:WalkupScanResourceType": string[];
+        }[];
+      }[];
+    }[];
+  };
+}
+
+export default class WalkupScanManifest {
+  private readonly data: WalkupScanManifestData;
+
+  constructor(data: WalkupScanManifestData) {
+    this.data = data;
+  }
+  static async createWalkupScanManifest(
+    content: string
+  ): Promise<WalkupScanManifest> {
+    const parsed = await parseString(content);
+    return new WalkupScanManifest(parsed);
+  }
+
+  get walkupScanDestinationsURI(): string | null {
+    const walkupScanToCompCaps = this.data["man:Manifest"]["map:ResourceMap"][
+      "0"
+    ]["map:ResourceNode"].find(
+      (x) =>
+        x["map:ResourceType"][0]["wus:WalkupScanResourceType"][0] ===
+        "WalkupScanDestinations"
+    );
+
+    if (walkupScanToCompCaps === undefined) {
+      return null;
+    }
+
+    return (
+      this.data["man:Manifest"]["map:ResourceMap"]["0"]["map:ResourceLink"][0][
+        "dd:ResourceURI"
+      ][0] + walkupScanToCompCaps["map:ResourceLink"][0]["dd:ResourceURI"][0]
+    );
+  }
+}

package/src/WalkupScanToCompCaps.ts

@@ -0,0 +1,36 @@
+"use strict";
+import { Parser } from "xml2js";
+const parser = new Parser();
+import { promisify } from "util";
+const parseString = promisify<string, WalkupScanToCompCapsData>(
+  parser.parseString
+);
+export interface WalkupScanToCompCapsData {
+  "wus:WalkupScanToCompCaps": {
+    "wus:MaxNetworkDestinations": string[];
+    "wus:SupportsMultiItemScanFromPlaten": string[];
+  };
+}
+
+export default class WalkupScanToCompCaps {
+  private readonly data: WalkupScanToCompCapsData;
+
+  constructor(data: WalkupScanToCompCapsData) {
+    this.data = data;
+  }
+
+  static async createWalkupScanToCompCaps(
+    content: string
+  ): Promise<WalkupScanToCompCaps> {
+    const parsed = await parseString(content);
+    return new WalkupScanToCompCaps(parsed);
+  }
+
+  get supportsMultiItemScanFromPlaten(): boolean {
+    return (
+      this.data["wus:WalkupScanToCompCaps"][
+        "wus:SupportsMultiItemScanFromPlaten"
+      ]["0"] === "true"
+    );
+  }
+}

package/src/WalkupScanToCompDestination.ts

@@ -1,21 +1,26 @@
 "use strict";
+import { Parser } from "xml2js";
+const parser = new Parser();
+import { promisify } from "util";
+import { KnownShortcut } from "./KnownShortcut";
+const parseString = promisify<string, WalkupScanToCompDestinationRoot>(
+  parser.parseString
+);
+
+interface WalkupScanToCompDestinationRoot {
+  "wus:WalkupScanToCompDestination": WalkupScanToCompDestinationData;
+}
 
 export interface WalkupScanToCompDestinationData {
   "dd:Name": string[];
   "dd:ResourceURI": string[];
   "dd3:Hostname": string[];
-  "wus:WalkupScanToCompDestination": {
-    "wus:WalkupScanToCompSettings": {
-      "0": {
-        "scantype:Scansettings": {
-          "0": {
-            "dd:ScanPlexMode": string[];
-          };
-        };
-        "wus:Shortcut": string[]; //can be 'SaveDocument1' or 'SavePhoto1'
-      };
-    };
-  };
+  "wus:WalkupScanToCompSettings": {
+    "scantype:ScanSettings": {
+      "dd:ScanPlexMode": string[];
+    }[];
+    "wus:Shortcut": KnownShortcut[];
+  }[];
 }
 
 export default class WalkupScanToCompDestination {
@@ -23,6 +28,14 @@ export default class WalkupScanToCompDestination {
   constructor(data: WalkupScanToCompDestinationData) {
     this.data = data;
   }
+  static async createWalkupScanToCompDestination(
+    content: string
+  ): Promise<WalkupScanToCompDestination> {
+    const parsed = await parseString(content);
+    return new WalkupScanToCompDestination(
+      parsed["wus:WalkupScanToCompDestination"]
+    );
+  }
 
   get name(): string {
     return this.data["dd:Name"][0];
@@ -36,20 +49,21 @@ export default class WalkupScanToCompDestination {
     return this.data["dd:ResourceURI"][0];
   }
 
-  get shortcut(): string {
-    if (
-      this.data["wus:WalkupScanToCompDestination"].hasOwnProperty(
-        "wus:WalkupScanToCompSettings"
-      )
-    ) {
-      return this.data["wus:WalkupScanToCompDestination"][
-        "wus:WalkupScanToCompSettings"
-      ]["0"]["wus:Shortcut"][0];
+  get shortcut(): null | KnownShortcut {
+    if (this.data.hasOwnProperty("wus:WalkupScanToCompSettings")) {
+      return this.data["wus:WalkupScanToCompSettings"]["0"]["wus:Shortcut"][0];
     }
-    return "";
+    return null;
   }
 
-  getContentType(): string {
-    return this.shortcut === "SaveDocument1" ? "Document" : "Photo";
+  get scanPlexMode(): string | null {
+    if (this.data.hasOwnProperty("wus:WalkupScanToCompSettings")) {
+      return (
+        this.data["wus:WalkupScanToCompSettings"]["0"]["scantype:ScanSettings"][
+          "0"
+        ]["dd:ScanPlexMode"][0] || null
+      );
+    }
+    return null;
   }
 }

package/src/WalkupScanToCompDestinations.ts

@@ -1,4 +1,10 @@
 "use strict";
+import { Parser } from "xml2js";
+const parser = new Parser();
+import { promisify } from "util";
+const parseString = promisify<string, WalkupScanToCompDestinationsData>(
+  parser.parseString
+);
 
 import WalkupScanToCompDestination, {
   WalkupScanToCompDestinationData,
@@ -15,6 +21,12 @@ export default class WalkupScanToCompDestinations {
   constructor(data: WalkupScanToCompDestinationsData) {
     this.data = data;
   }
+  static async createWalkupScanToCompDestinations(
+    content: string
+  ): Promise<WalkupScanToCompDestinations> {
+    const parsed = await parseString(content);
+    return new WalkupScanToCompDestinations(parsed);
+  }
 
   get destinations(): WalkupScanToCompDestination[] {
     let walkupScanToCompDestinations =

package/src/WalkupScanToCompEvent.ts

@@ -1,9 +1,15 @@
 "use strict";
+import { Parser } from "xml2js";
+const parser = new Parser();
+import { promisify } from "util";
+const parseString = promisify<string, WalkupScanToCompEventData>(
+  parser.parseString
+);
 
 export interface WalkupScanToCompEventData {
   "wus:WalkupScanToCompEvent": {
-    'wus:WalkupScanToCompEventType': string[]
-  }
+    "wus:WalkupScanToCompEventType": string[];
+  };
 }
 
 export default class WalkupScanToCompEvent {
@@ -11,8 +17,14 @@ export default class WalkupScanToCompEvent {
   constructor(data: WalkupScanToCompEventData) {
     this.data = data;
   }
+  static async createWalkupScanToCompEvent(content: string) {
+    const parsed = await parseString(content);
+    return new WalkupScanToCompEvent(parsed);
+  }
 
   get eventType(): string {
-    return this.data["wus:WalkupScanToCompEvent"]["wus:WalkupScanToCompEventType"][0];
+    return this.data["wus:WalkupScanToCompEvent"][
+      "wus:WalkupScanToCompEventType"
+    ][0];
   }
 }

package/src/WalkupScanToCompManifest.ts

@@ -0,0 +1,59 @@
+"use strict";
+import { Parser } from "xml2js";
+const parser = new Parser();
+import { promisify } from "util";
+const parseString = promisify<string, WalkupScanToCompManifestData>(
+  parser.parseString
+);
+
+export interface WalkupScanToCompManifestData {
+  "man:Manifest": {
+    "map:ResourceMap": {
+      "map:ResourceLink": {
+        "dd:ResourceURI": string[];
+      }[];
+      "map:ResourceNode": {
+        "map:ResourceLink": {
+          "dd:ResourceURI": string[];
+        }[];
+        "map:ResourceType": {
+          "wus:WalkupScanToCompResourceType": string[];
+        }[];
+      }[];
+    }[];
+  };
+}
+
+export default class WalkupScanToCompManifest {
+  private readonly data: WalkupScanToCompManifestData;
+
+  constructor(data: WalkupScanToCompManifestData) {
+    this.data = data;
+  }
+  static async createWalkupScanToCompManifest(
+    content: string
+  ): Promise<WalkupScanToCompManifest> {
+    const parsed = await parseString(content);
+    return new WalkupScanToCompManifest(parsed);
+  }
+
+  get WalkupScanToCompCapsURI(): string | null {
+    const walkupScanToCompCaps = this.data["man:Manifest"]["map:ResourceMap"][
+      "0"
+    ]["map:ResourceNode"].find(
+      (x) =>
+        x["map:ResourceType"][0]["wus:WalkupScanToCompResourceType"][0] ===
+        "WalkupScanToCompCaps"
+    );
+
+    if (walkupScanToCompCaps === undefined) {
+      return null;
+    }
+
+    return (
+      this.data["man:Manifest"]["map:ResourceMap"]["0"]["map:ResourceLink"][0][
+        "dd:ResourceURI"
+      ][0] + walkupScanToCompCaps["map:ResourceLink"][0]["dd:ResourceURI"][0]
+    );
+  }
+}

package/src/delay.ts

@@ -0,0 +1,5 @@
+export function delay(t: number): Promise<void> {
+  return new Promise(function (resolve) {
+    setTimeout(resolve, t);
+  });
+}