mindee 2.0.0 → 2.0.1

package/{dist/src → src}/fields/customDocs.d.ts

@@ -8,7 +8,7 @@ export declare class ClassificationField {
     });
     toString(): string;
 }
-export declare class ListFieldItem {
+export declare class ListFieldValue {
     content: any;
     /**
      * The confidence score of the prediction.
@@ -29,7 +29,7 @@ export declare class ListFieldItem {
     toString(): string;
 }
 export declare class ListField {
-    values: ListFieldItem[];
+    readonly values: ListFieldValue[];
     confidence: number;
     /** True if the field was reconstructed or computed using other fields. */
     reconstructed: boolean;

package/{dist/src → src}/fields/customDocs.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ListField = exports.ListFieldItem = exports.ClassificationField = void 0;
+exports.ListField = exports.ListFieldValue = exports.ClassificationField = void 0;
 const geometry_1 = require("../geometry");
 class ClassificationField {
     constructor({ prediction }) {
@@ -12,7 +12,7 @@ class ClassificationField {
     }
 }
 exports.ClassificationField = ClassificationField;
-class ListFieldItem {
+class ListFieldValue {
     constructor(prediction) {
         /**
          * Contains exactly 4 relative vertices coordinates (points) of a right
@@ -35,7 +35,7 @@ class ListFieldItem {
         return `${this.content}`;
     }
 }
-exports.ListFieldItem = ListFieldItem;
+exports.ListFieldValue = ListFieldValue;
 class ListField {
     constructor({ prediction, reconstructed = false, pageId }) {
         this.values = [];
@@ -44,7 +44,7 @@ class ListField {
         this.pageId = pageId !== undefined ? pageId : prediction["page_id"];
         if (Object.prototype.hasOwnProperty.call(prediction, "values")) {
             prediction["values"].forEach((field) => {
-                this.values.push(new ListFieldItem(field));
+                this.values.push(new ListFieldValue(field));
             });
         }
     }

package/{dist/src → src}/fields/index.d.ts

@@ -6,6 +6,6 @@ export { Amount } from "./amount";
 export { DateField } from "./date";
 export { BaseField } from "./field";
 export { Field } from "./field";
-export { ListField, ListFieldItem, ClassificationField } from "./customDocs";
+export { ListField, ListFieldValue, ClassificationField } from "./customDocs";
 export { FullText } from "./fullText";
 export { CompanyRegistration } from "./companyRegistration";

package/{dist/src → src}/fields/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CompanyRegistration = exports.FullText = exports.ClassificationField = exports.ListFieldItem = exports.ListField = exports.Field = exports.BaseField = exports.DateField = exports.Amount = exports.Locale = exports.Orientation = exports.PaymentDetails = exports.TaxField = void 0;
+exports.CompanyRegistration = exports.FullText = exports.ClassificationField = exports.ListFieldValue = exports.ListField = exports.Field = exports.BaseField = exports.DateField = exports.Amount = exports.Locale = exports.Orientation = exports.PaymentDetails = exports.TaxField = void 0;
 var tax_1 = require("./tax");
 Object.defineProperty(exports, "TaxField", { enumerable: true, get: function () { return tax_1.TaxField; } });
 var paymentDetails_1 = require("./paymentDetails");
@@ -19,7 +19,7 @@ var field_2 = require("./field");
 Object.defineProperty(exports, "Field", { enumerable: true, get: function () { return field_2.Field; } });
 var customDocs_1 = require("./customDocs");
 Object.defineProperty(exports, "ListField", { enumerable: true, get: function () { return customDocs_1.ListField; } });
-Object.defineProperty(exports, "ListFieldItem", { enumerable: true, get: function () { return customDocs_1.ListFieldItem; } });
+Object.defineProperty(exports, "ListFieldValue", { enumerable: true, get: function () { return customDocs_1.ListFieldValue; } });
 Object.defineProperty(exports, "ClassificationField", { enumerable: true, get: function () { return customDocs_1.ClassificationField; } });
 var fullText_1 = require("./fullText");
 Object.defineProperty(exports, "FullText", { enumerable: true, get: function () { return fullText_1.FullText; } });

package/{dist/src → src}/fields/tax.js

@@ -13,7 +13,6 @@ class TaxField extends field_1.Field {
      * @param {Integer} pageNumber - Page ID for multi-page document
      */
     constructor({ prediction, valueKey = "value", rateKey = "rate", codeKey = "code", reconstructed = false, pageId = undefined, }) {
-        var _a;
         super({ prediction, valueKey, reconstructed, pageId });
         /** The tax amount. */
         this.value = undefined;
@@ -24,7 +23,7 @@ class TaxField extends field_1.Field {
         this.rate = +parseFloat(prediction[rateKey]);
         if (isNaN(this.rate))
             this.rate = undefined;
-        this.code = (_a = prediction[codeKey]) === null || _a === void 0 ? void 0 : _a.toString();
+        this.code = prediction[codeKey]?.toString();
         if (this.code === "N/A" || this.code === "None") {
             this.code = undefined;
         }

package/src/inputs.js

@@ -0,0 +1,196 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BytesInput = exports.StreamInput = exports.Base64Input = exports.PathInput = exports.Input = exports.INPUT_TYPE_PATH = exports.INPUT_TYPE_BYTES = exports.INPUT_TYPE_BASE64 = exports.INPUT_TYPE_STREAM = void 0;
+const fs_1 = require("fs");
+const path = __importStar(require("path"));
+const fileType = __importStar(require("file-type"));
+const handler_1 = require("./errors/handler");
+const pdf_lib_1 = require("pdf-lib");
+const node_buffer_1 = require("node:buffer");
+const logger_1 = require("./logger");
+exports.INPUT_TYPE_STREAM = "stream";
+exports.INPUT_TYPE_BASE64 = "base64";
+exports.INPUT_TYPE_BYTES = "bytes";
+exports.INPUT_TYPE_PATH = "path";
+const MIMETYPES = new Map([
+    [".pdf", "application/pdf"],
+    [".heic", "image/heic"],
+    [".jpg", "image/jpeg"],
+    [".jpeg", "image/jpeg"],
+    [".png", "image/png"],
+    [".tif", "image/tiff"],
+    [".tiff", "image/tiff"],
+    [".webp", "image/webp"],
+]);
+const ALLOWED_INPUT_TYPES = [
+    exports.INPUT_TYPE_STREAM,
+    exports.INPUT_TYPE_BASE64,
+    exports.INPUT_TYPE_BYTES,
+    exports.INPUT_TYPE_PATH,
+];
+class Input {
+    /**
+     * @param {String} inputType - the type of input used in file ("base64", "path", "dummy").
+     *                             NB: dummy is only used for tests purposes
+     * @param {Boolean} cutPages
+     * NB: Because of async calls, init() should be called after creating the object
+     */
+    constructor({ inputType }) {
+        this.MAX_DOC_PAGES = 3;
+        this.filename = "";
+        this.mimeType = "";
+        this.fileObject = node_buffer_1.Buffer.alloc(0);
+        // Check if inputType is valid
+        if (!ALLOWED_INPUT_TYPES.includes(inputType)) {
+            const allowed = Array.from(MIMETYPES.keys()).join(", ");
+            handler_1.errorHandler.throw(new Error(`Invalid input type, must be one of ${allowed}.`));
+        }
+        this.inputType = inputType;
+        logger_1.logger.debug(`Loading file from: ${inputType}`);
+    }
+    async init() {
+        throw new Error("not Implemented");
+    }
+    isPdf() {
+        return this.mimeType === "application/pdf";
+    }
+    async checkMimetype() {
+        let mimeType;
+        const fileExt = path.extname(this.filename);
+        if (fileExt) {
+            mimeType = MIMETYPES.get(fileExt.toLowerCase()) || "";
+        }
+        else {
+            const guess = await fileType.fromBuffer(this.fileObject);
+            if (guess !== undefined) {
+                mimeType = guess.mime;
+            }
+            else {
+                throw "Could not determine the MIME type of the file";
+            }
+        }
+        if (!mimeType) {
+            const allowed = Array.from(MIMETYPES.keys()).join(", ");
+            const err = new Error(`Invalid file type, must be one of ${allowed}.`);
+            handler_1.errorHandler.throw(err);
+        }
+        logger_1.logger.debug(`File is of type: ${mimeType}`);
+        return mimeType;
+    }
+    async countPages() {
+        const pdfDocument = await pdf_lib_1.PDFDocument.load(this.fileObject, {
+            ignoreEncryption: true,
+        });
+        return pdfDocument.getPageCount();
+    }
+    /** Merge PDF pages */
+    async cutPdf() {
+        const currentPdf = await pdf_lib_1.PDFDocument.load(this.fileObject, {
+            ignoreEncryption: true,
+        });
+        const pdfLength = currentPdf.getPageCount();
+        if (pdfLength <= this.MAX_DOC_PAGES) {
+            return;
+        }
+        const newPdf = await pdf_lib_1.PDFDocument.create();
+        const pagesNumbers = [0, pdfLength - 2, pdfLength - 1].slice(0, this.MAX_DOC_PAGES);
+        logger_1.logger.debug(`Cutting PDF, keeping pages: ${pagesNumbers}`);
+        const pages = await newPdf.copyPages(currentPdf, pagesNumbers);
+        pages.forEach((page) => newPdf.addPage(page));
+        const data = await newPdf.save();
+        this.fileObject = node_buffer_1.Buffer.from(data);
+    }
+}
+exports.Input = Input;
+class PathInput extends Input {
+    constructor({ inputPath }) {
+        super({
+            inputType: exports.INPUT_TYPE_PATH,
+        });
+        this.inputPath = inputPath;
+        this.filename = path.basename(this.inputPath);
+    }
+    async init() {
+        logger_1.logger.debug(`Loading from: ${this.inputPath}`);
+        this.fileObject = node_buffer_1.Buffer.from(await fs_1.promises.readFile(this.inputPath));
+        this.mimeType = await this.checkMimetype();
+    }
+}
+exports.PathInput = PathInput;
+class Base64Input extends Input {
+    constructor({ inputString, filename }) {
+        super({
+            inputType: exports.INPUT_TYPE_BASE64,
+        });
+        this.filename = filename;
+        this.inputString = inputString;
+    }
+    async init() {
+        this.fileObject = node_buffer_1.Buffer.from(this.inputString, "base64");
+        this.mimeType = await this.checkMimetype();
+        // clear out the string
+        this.inputString = "";
+    }
+}
+exports.Base64Input = Base64Input;
+class StreamInput extends Input {
+    constructor({ inputStream, filename }) {
+        super({
+            inputType: exports.INPUT_TYPE_STREAM,
+        });
+        this.filename = filename;
+        this.inputStream = inputStream;
+    }
+    async init() {
+        this.fileObject = await this.stream2buffer(this.inputStream);
+        this.mimeType = await this.checkMimetype();
+    }
+    async stream2buffer(stream) {
+        return new Promise((resolve, reject) => {
+            const _buf = Array();
+            stream.on("data", (chunk) => _buf.push(chunk));
+            stream.on("end", () => resolve(node_buffer_1.Buffer.concat(_buf)));
+            stream.on("error", (err) => reject(`Error converting stream - ${err}`));
+        });
+    }
+}
+exports.StreamInput = StreamInput;
+class BytesInput extends Input {
+    constructor({ inputBytes, filename }) {
+        super({
+            inputType: exports.INPUT_TYPE_BYTES,
+        });
+        this.filename = filename;
+        this.inputBytes = inputBytes;
+    }
+    async init() {
+        this.fileObject = node_buffer_1.Buffer.from(this.inputBytes, "hex");
+        this.mimeType = await this.checkMimetype();
+        // clear out the string
+        this.inputBytes = "";
+    }
+}
+exports.BytesInput = BytesInput;

package/bin/mindee

@@ -1,3 +0,0 @@
-#!/usr/bin/env node
-
-require('../dist/src/cli').cli();

package/dist/package.json

@@ -1,70 +0,0 @@
-{
-    "name": "mindee",
-    "version": "2.0.0",
-    "description": "Mindee Client Library for Node.js",
-    "main": "src/index.js",
-    "license": "MIT",
-    "scripts": {
-        "build": "tsc --build",
-        "clean": "rm -rf ./dist",
-        "test": "mocha 'tests/**/*.spec.ts'",
-        "lint-fix": "eslint 'src/**/*.ts' --fix",
-        "lint": "eslint 'src/**/*.ts' --report-unused-disable-directives && echo 'Your .ts files look good.'",
-        "docs": "jsdoc -r src -d docs"
-    },
-    "files": [
-        "dist/",
-        "bin/",
-        "LICENSE",
-        "README.md",
-        "CHANGELOG.md"
-    ],
-    "engines": {
-        "node": ">= 14.0.0"
-    },
-    "repository": {
-        "type": "git",
-        "url": "git+https://github.com/mindee/mindee-api-nodejs.git"
-    },
-    "author": {
-        "name": "Mindee",
-        "email": "devrel@mindee.com",
-        "url": "https://mindee.com/"
-    },
-    "bugs": {
-        "url": "https://github.com/mindee/mindee-api-nodejs/issues"
-    },
-    "homepage": "https://mindee.com/",
-    "devDependencies": {
-        "@tsconfig/node16": "^1.0.3",
-        "@types/chai": "^4.3.1",
-        "@types/mocha": "^9.1.1",
-        "@types/node": "^17.0.38",
-        "@typescript-eslint/eslint-plugin": "^5.30.0",
-        "@typescript-eslint/parser": "^5.30.0",
-        "chai": "^4.3.6",
-        "eslint": "^8.18.0",
-        "eslint-config-prettier": "^8.5.0",
-        "eslint-plugin-prettier": "^4.1.0",
-        "jsdoc": "^3.6.10",
-        "mocha": "^10.0.0",
-        "prettier": "^2.7.1",
-        "ts-node": "^10.8.1",
-        "typescript": "^4.7.4"
-    },
-    "dependencies": {
-        "commander": "^9.4.0",
-        "file-type": "^16.5.4",
-        "form-data": "^3.0.1",
-        "mrz": "^3.1.4",
-        "pdf-lib": "^1.17.1"
-    },
-    "keywords": [
-        "typescript",
-        "mindee",
-        "api",
-        "client",
-        "client library",
-        "nodejs"
-    ]
-}

package/dist/src/cli.js

@@ -1,117 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.cli = void 0;
-const commander_1 = require("commander");
-const documents_1 = require("./documents");
-const api_1 = require("./api");
-const client_1 = require("./client");
-const constants_1 = require("./constants");
-const program = new commander_1.Command();
-const COMMAND_INVOICE = "invoice";
-const COMMAND_RECEIPT = "receipt";
-const COMMAND_PASSPORT = "passport";
-const COMMAND_FINANCIAL = "financial";
-const COMMAND_CUSTOM = "custom";
-const CLI_COMMAND_CONFIG = new Map([
-    [COMMAND_INVOICE, constants_1.ProductConfigs.getByDocType(documents_1.DOC_TYPE_INVOICE)],
-    [COMMAND_RECEIPT, constants_1.ProductConfigs.getByDocType(documents_1.DOC_TYPE_RECEIPT)],
-    [COMMAND_PASSPORT, constants_1.ProductConfigs.getByDocType(documents_1.DOC_TYPE_PASSPORT)],
-    [COMMAND_FINANCIAL, constants_1.ProductConfigs.getByDocType(documents_1.DOC_TYPE_FINANCIAL)],
-    [COMMAND_CUSTOM, constants_1.ProductConfigs.getByDocType(documents_1.DOC_TYPE_CUSTOM)],
-]);
-function predictCall(command, inputPath, options) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const conf = CLI_COMMAND_CONFIG.get(command);
-        if (conf === undefined) {
-            throw new Error(`Invalid document type ${command}`);
-        }
-        const mindeeClient = new client_1.Client({
-            apiKey: options.apiKey,
-            debug: options.debug,
-        });
-        if (command === COMMAND_CUSTOM) {
-            mindeeClient.addEndpoint({
-                accountName: options.user,
-                documentType: options.documentType,
-            });
-        }
-        const doc = mindeeClient.docFromPath(inputPath);
-        const params = {
-            docType: command === COMMAND_CUSTOM ? options.documentType : conf.docType,
-            username: command === COMMAND_CUSTOM ? options.user : api_1.STANDARD_API_OWNER,
-            cutPages: options.cutPages,
-            fullText: options.fullText,
-        };
-        // Tried setting the response by using the responseClass property in constants.PRODUCTS_CONFIG
-        // This compiled, but threw an exception:
-        //   TypeError: responseType is not a constructor
-        //
-        // So using a switch to explicitly set the response class parameter. Ugly, but works.
-        // Improvements welcome!
-        let response;
-        switch (command) {
-            case COMMAND_INVOICE:
-                response = yield doc.parse(api_1.InvoiceResponse, params);
-                break;
-            case COMMAND_RECEIPT:
-                response = yield doc.parse(api_1.ReceiptResponse, params);
-                break;
-            case COMMAND_FINANCIAL:
-                response = yield doc.parse(api_1.FinancialDocResponse, params);
-                break;
-            case COMMAND_PASSPORT:
-                response = yield doc.parse(api_1.PassportResponse, params);
-                break;
-            case COMMAND_CUSTOM:
-                response = yield doc.parse(api_1.CustomResponse, params);
-                break;
-            default:
-                throw `Unhandled command: ${command}`;
-        }
-        if (response.document) {
-            console.log(`\n${response.document}`);
-        }
-    });
-}
-function cli() {
-    program.name("mindee");
-    program.option("-d, --debug", "high verbosity mode");
-    CLI_COMMAND_CONFIG.forEach((info, name) => {
-        const prog = program.command(name);
-        prog.description(info.description);
-        prog.option("-k, --api-key <api_key>", "API key for document endpoint");
-        prog.option("-C, --no-cut-pages", "Don't cut document pages");
-        if (info.fullText) {
-            prog.option("-t, --full-text", "Include full document text in response");
-        }
-        if (name === COMMAND_CUSTOM) {
-            prog.requiredOption("-u, --user <username>", "API account name for the endpoint");
-            prog.option("-v, --version <version>", "API account name for the endpoint");
-            prog.argument("<endpoint_name>", "API endpoint name");
-        }
-        prog.argument("<input_path>", "Full path to the file");
-        if (name === COMMAND_CUSTOM) {
-            prog.action((endpointName, inputPath, options, command) => {
-                const allOptions = Object.assign(Object.assign(Object.assign({}, program.opts()), options), { documentType: endpointName });
-                predictCall(command.name(), inputPath, allOptions);
-            });
-        }
-        else {
-            prog.action((inputPath, options, command) => {
-                const allOptions = Object.assign(Object.assign(Object.assign({}, program.opts()), options), { endpointName: undefined });
-                predictCall(command.name(), inputPath, allOptions);
-            });
-        }
-    });
-    program.parse(process.argv);
-}
-exports.cli = cli;