node-hp-scan-to 1.6.1 → 1.7.1

package/src/ScanJobManifest.ts

@@ -1,56 +0,0 @@
-"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

@@ -1,84 +0,0 @@
-import xml2js from "xml2js";
-import { InputSource } from "./InputSource";
-
-const parser = new xml2js.Parser();
-export default class ScanJobSettings {
-  private readonly inputSource: InputSource;
-  private readonly contentType: "Document" | "Photo";
-  private readonly resolution: number;
-  private readonly width: number | null;
-  private readonly height: number | null;
-  private readonly isDuplex: boolean;
-
-  constructor(
-    inputSource: InputSource,
-    contentType: "Document" | "Photo",
-    resolution: number,
-    width: number | null,
-    height: number | null,
-    isDuplex: boolean,
-  ) {
-    this.inputSource = inputSource;
-    this.contentType = contentType;
-    this.resolution = resolution;
-    this.width = width;
-    this.height = height;
-    this.isDuplex = isDuplex;
-  }
-
-  async toXML(): Promise<string> {
-    const rawJob =
-      '<?xml version="1.0" encoding="UTF-8"?>\n' +
-      '<ScanSettings xmlns="http://www.hp.com/schemas/imaging/con/cnx/scan/2008/08/19" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.hp.com/schemas/imaging/con/cnx/scan/2008/08/19 Scan Schema - 0.26.xsd">\n' +
-      "\t<XResolution>200</XResolution>\n" +
-      "\t<YResolution>200</YResolution>\n" +
-      "\t<XStart>0</XStart>\n" +
-      "\t<YStart>0</YStart>\n" +
-      "\t<Width>2481</Width>\n" +
-      "\t<Height>3507</Height>\n" +
-      "\t<Format>Jpeg</Format>\n" +
-      "\t<CompressionQFactor>0</CompressionQFactor>\n" +
-      "\t<ColorSpace>Color</ColorSpace>\n" +
-      "\t<BitDepth>8</BitDepth>\n" +
-      "\t<InputSource>Adf</InputSource>\n" +
-      "\t<GrayRendering>NTSC</GrayRendering>\n" +
-      "\t<ToneMap>\n" +
-      "\t\t<Gamma>1000</Gamma>\n" +
-      "\t\t<Brightness>1000</Brightness>\n" +
-      "\t\t<Contrast>1000</Contrast>\n" +
-      "\t\t<Highlite>179</Highlite>\n" +
-      "\t\t<Shadow>25</Shadow>\n" +
-      "\t\t<Threshold>0</Threshold>\n" +
-      "\t</ToneMap>\n" +
-      "\t<SharpeningLevel>128</SharpeningLevel>\n" +
-      "\t<NoiseRemoval>0</NoiseRemoval>\n" +
-      "\t<ContentType>Document</ContentType>\n" +
-      "</ScanSettings>";
-
-    const parsed = await parser.parseStringPromise(rawJob);
-
-    parsed.ScanSettings.XResolution[0] = this.resolution;
-    parsed.ScanSettings.YResolution[0] = this.resolution;
-
-    if (this.width !== null) {
-      parsed.ScanSettings.Width = this.width;
-    }
-
-    if (this.height !== null) {
-      parsed.ScanSettings.Height = this.height;
-    }
-
-    parsed.ScanSettings.InputSource[0] = this.inputSource;
-    if (this.inputSource === InputSource.Adf && this.isDuplex) {
-      parsed.ScanSettings["AdfOptions"] = [{ AdfOption: ["Duplex"] }];
-    }
-    parsed.ScanSettings.ContentType[0] = this.contentType;
-
-    const builder = new xml2js.Builder({
-      xmldec: { version: "1.0", encoding: "UTF-8", standalone: false },
-      renderOpts: { pretty: true, indent: "\t", newline: "\n" },
-    });
-
-    return builder.buildObject(parsed);
-  }
-}

package/src/ScanStatus.ts

@@ -1,48 +0,0 @@
-"use strict";
-import { Parser } from "xml2js";
-const parser = new Parser();
-import { promisify } from "util";
-import { InputSource } from "./InputSource";
-const parseString = promisify<string, ScanStatusData>(parser.parseString);
-
-export interface ScanStatusData {
-  ScanStatus: {
-    ScannerState: { "0": string };
-    AdfState: { "0": string };
-  };
-}
-
-export default class ScanStatus {
-  private readonly data: ScanStatusData;
-  constructor(data: ScanStatusData) {
-    this.data = data;
-  }
-
-  static async createScanStatus(content: string): Promise<ScanStatus> {
-    const parsed = await parseString(content);
-    return new ScanStatus(parsed);
-  }
-
-  get scannerState(): string | "Idle" {
-    return this.data["ScanStatus"].ScannerState["0"];
-  }
-
-  get adfState(): string {
-    if (
-      Object.prototype.hasOwnProperty.call(this.data["ScanStatus"], "AdfState")
-    ) {
-      //not all printers have an automatic document feeder
-      return this.data["ScanStatus"].AdfState["0"];
-    } else {
-      return "";
-    }
-  }
-
-  isLoaded(): boolean {
-    return this.adfState === "Loaded";
-  }
-
-  getInputSource(): InputSource {
-    return this.isLoaded() ? InputSource.Adf : InputSource.Platen;
-  }
-}

package/src/WalkupScanDestination.ts

@@ -1,74 +0,0 @@
-"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:WalkupScanSettings": {
-    "scantype:ScanSettings": {
-      "dd:ScanPlexMode": string[];
-    }[];
-    "wus:Shortcut": KnownShortcut[];
-  }[];
-}
-
-export default class WalkupScanDestination {
-  private readonly data: WalkupScanDestinationData;
-  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["dd3:Hostname"][0];
-  }
-
-  get resourceURI(): string {
-    return this.data["dd:ResourceURI"][0];
-  }
-
-  get shortcut(): null | KnownShortcut {
-    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 (
-      Object.prototype.hasOwnProperty.call(this.data, "wus:WalkupScanSettings")
-    ) {
-      return this.data["wus:WalkupScanSettings"]["0"][
-        "scantype:ScanSettings"
-      ][0]["dd:ScanPlexMode"][0];
-    }
-    return null;
-  }
-}

package/src/WalkupScanDestinations.ts

@@ -1,46 +0,0 @@
-"use strict";
-import { Parser } from "xml2js";
-const parser = new Parser();
-import { promisify } from "util";
-const parseString = promisify<string, WalkupScanDestinationsData>(
-  parser.parseString,
-);
-
-import WalkupScanDestination, {
-  WalkupScanDestinationData,
-} from "./WalkupScanDestination";
-
-export interface WalkupScanDestinationsData {
-  "wus:WalkupScanDestinations": {
-    "wus:WalkupScanDestination": WalkupScanDestinationData[];
-  };
-}
-
-export default class WalkupScanDestinations {
-  private readonly data: WalkupScanDestinationsData;
-  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[] {
-    const walkupScanDestinations = this.data["wus:WalkupScanDestinations"];
-    if (
-      Object.prototype.hasOwnProperty.call(
-        walkupScanDestinations,
-        "wus:WalkupScanDestination",
-      )
-    ) {
-      return walkupScanDestinations["wus:WalkupScanDestination"].map(
-        (x) => new WalkupScanDestination(x),
-      );
-    } else {
-      return [];
-    }
-  }
-}

package/src/WalkupScanManifest.ts

@@ -1,59 +0,0 @@
-"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

@@ -1,36 +0,0 @@
-"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,79 +0,0 @@
-"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:WalkupScanToCompSettings": {
-    "scantype:ScanSettings": {
-      "dd:ScanPlexMode": string[];
-    }[];
-    "wus:Shortcut": KnownShortcut[];
-  }[];
-}
-
-export default class WalkupScanToCompDestination {
-  private readonly data: WalkupScanToCompDestinationData;
-  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];
-  }
-
-  get hostname(): string {
-    return this.data["dd3:Hostname"][0];
-  }
-
-  get resourceURI(): string {
-    return this.data["dd:ResourceURI"][0];
-  }
-
-  get shortcut(): null | KnownShortcut {
-    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 (
-      Object.prototype.hasOwnProperty.call(
-        this.data,
-        "wus:WalkupScanToCompSettings",
-      )
-    ) {
-      return (
-        this.data["wus:WalkupScanToCompSettings"]["0"]["scantype:ScanSettings"][
-          "0"
-        ]["dd:ScanPlexMode"][0] || null
-      );
-    }
-    return null;
-  }
-}

package/src/WalkupScanToCompDestinations.ts

@@ -1,47 +0,0 @@
-"use strict";
-import { Parser } from "xml2js";
-const parser = new Parser();
-import { promisify } from "util";
-const parseString = promisify<string, WalkupScanToCompDestinationsData>(
-  parser.parseString,
-);
-
-import WalkupScanToCompDestination, {
-  WalkupScanToCompDestinationData,
-} from "./WalkupScanToCompDestination";
-
-export interface WalkupScanToCompDestinationsData {
-  "wus:WalkupScanToCompDestinations": {
-    "wus:WalkupScanToCompDestination": WalkupScanToCompDestinationData[];
-  };
-}
-
-export default class WalkupScanToCompDestinations {
-  private readonly data: WalkupScanToCompDestinationsData;
-  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[] {
-    const walkupScanToCompDestinations =
-      this.data["wus:WalkupScanToCompDestinations"];
-    if (
-      Object.prototype.hasOwnProperty.call(
-        walkupScanToCompDestinations,
-        "wus:WalkupScanToCompDestination",
-      )
-    ) {
-      return walkupScanToCompDestinations[
-        "wus:WalkupScanToCompDestination"
-      ].map((x) => new WalkupScanToCompDestination(x));
-    } else {
-      return [];
-    }
-  }
-}

package/src/WalkupScanToCompEvent.ts

@@ -1,30 +0,0 @@
-"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[];
-  };
-}
-
-export default class WalkupScanToCompEvent {
-  private readonly data: WalkupScanToCompEventData;
-  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];
-  }
-}

package/src/WalkupScanToCompManifest.ts

@@ -1,59 +0,0 @@
-"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/commitInfo.json

@@ -1,3 +0,0 @@
-{
-  "commitId": "691a0d2906379ed370b16a4d804bff34ca6ecf10"
-}

package/src/delay.ts

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

package/src/healthcheck.ts

@@ -1,17 +0,0 @@
-import http from "http";
-
-export function startHealthCheckServer(PORT: number) {
-  const server = http.createServer((req, res) => {
-    if (req.method === "GET" && req.url === "/health") {
-      res.writeHead(200, { "Content-Type": "application/json" });
-      res.end(JSON.stringify({ status: "healthy" }));
-    } else {
-      res.writeHead(404, { "Content-Type": "text/plain" });
-      res.end("Not Found");
-    }
-  });
-
-  server.listen(PORT, () => {
-    console.log(`Health endpoint exposed on port ${PORT} on path: /health`);
-  });
-}