mindee 1.2.0 → 1.3.2

package/dist/api/request.js

@@ -0,0 +1,90 @@
+"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;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.request = void 0;
+const https = __importStar(require("https"));
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore
+const package_json_1 = require("../../package.json");
+const url_1 = require("url");
+const form_data_1 = __importDefault(require("form-data"));
+const os = __importStar(require("os"));
+const request = (url, method, headers, input, includeWords = false) => {
+    return new Promise(function (resolve, reject) {
+        const form = new form_data_1.default();
+        let body;
+        headers["User-Agent"] = `mindee-api-nodejs@v${package_json_1.version} nodejs-${process.version} ${os.type().toLowerCase()}`;
+        if (["path", "stream"].includes(input.inputType)) {
+            const fileParams = { filename: input.filename };
+            form.append("document", input.fileObject, fileParams);
+            if (includeWords)
+                form.append("include_mvision", "true");
+            headers = Object.assign(Object.assign({}, headers), form.getHeaders());
+        }
+        else if (input.inputType === "base64") {
+            const body_obj = { document: input.fileObject };
+            if (includeWords)
+                body_obj["include_mvision"] = "true";
+            body = JSON.stringify(body_obj);
+            headers["Content-Type"] = "application/json";
+            headers["Content-Length"] = body.length;
+        }
+        const uri = new url_1.URL(url);
+        const options = {
+            method: method,
+            headers: headers,
+            hostname: uri.hostname,
+            path: `${uri.pathname}${uri.search}`,
+        };
+        const req = https.request(options, function (res) {
+            let responseBody = [];
+            res.on("data", function (chunk) {
+                responseBody += chunk;
+            });
+            res.on("end", function () {
+                try {
+                    resolve(Object.assign(Object.assign({}, res), { data: JSON.parse(responseBody) }));
+                }
+                catch (error) {
+                    console.log(responseBody, error);
+                }
+            });
+        });
+        req.on("error", (err) => {
+            reject(err);
+        });
+        if (["path", "stream"].includes(input.inputType)) {
+            form.pipe(req);
+        }
+        if (input.inputType === "base64") {
+            req.write(body);
+            req.end();
+        }
+    });
+};
+exports.request = request;

package/dist/api/response.js

@@ -0,0 +1,91 @@
+"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());
+    });
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Response = void 0;
+const receipt_1 = require("@documents/receipt");
+const invoice_1 = require("@documents/invoice");
+const financialDocument_1 = require("@documents/financialDocument");
+const promises_1 = __importDefault(require("fs/promises"));
+class Response {
+    constructor(_a) {
+        var { httpResponse, documentType, input, error, reconsctruted = false } = _a, args = __rest(_a, ["httpResponse", "documentType", "input", "error", "reconsctruted"]);
+        this.httpResponse = httpResponse;
+        this.documentType = documentType;
+        this.input = input;
+        if (!error && !reconsctruted)
+            this.formatResponse();
+        if (reconsctruted === true) {
+            Object.assign(this, args);
+        }
+    }
+    dump(path) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield promises_1.default.writeFile(path, JSON.stringify(Object.entries(this)));
+        });
+    }
+    static load(path) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const file = promises_1.default.readFile(path);
+            const args = JSON.parse(file);
+            return new Response(Object.assign({ reconsctruted: true }, args));
+        });
+    }
+    formatResponse() {
+        const http_data_document = this.httpResponse.data.document;
+        const constructors = {
+            receipt: (params) => new receipt_1.Receipt(params),
+            invoice: (params) => new invoice_1.Invoice(params),
+            financialDocument: (params) => new financialDocument_1.FinancialDocument(params),
+        };
+        const predictions = http_data_document.inference.pages.entries();
+        this[`${this.documentType}s`] = [];
+        const document_words_content = [];
+        // Create a list of Document (Receipt, Invoice...) for each page of the input document
+        for (const [pageNumber, prediction] of predictions) {
+            let page_words_content = [];
+            if ("ocr" in http_data_document &&
+                Object.keys(http_data_document.ocr).length > 0) {
+                page_words_content =
+                    http_data_document.ocr["mvision-v1"].pages[pageNumber].all_words;
+                document_words_content.push(...http_data_document.ocr["mvision-v1"].pages[pageNumber].all_words);
+            }
+            this[`${this.documentType}s`].push(constructors[this.documentType]({
+                apiPrediction: prediction.prediction,
+                inputFile: this.input,
+                pageNumber: pageNumber,
+                words: page_words_content,
+            }));
+        }
+        // Merge the list of Document into a unique Document
+        this[this.documentType] = constructors[this.documentType]({
+            apiPrediction: http_data_document.inference.prediction,
+            inputFile: this.input,
+            pageNumber: http_data_document.n_pages,
+            level: "document",
+            words: document_words_content,
+        });
+    }
+}
+exports.Response = Response;

package/dist/documents/document.js

@@ -0,0 +1,80 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Document = void 0;
+const promises_1 = __importDefault(require("fs/promises"));
+class Document {
+    /**
+     * Takes a list of Documents and return one Document where
+     * each field is set with the maximum probability field
+     * @param {Input} inputFile - input file given to parse the document
+     */
+    constructor(inputFile = undefined) {
+        this.filepath = undefined;
+        this.filename = undefined;
+        this.fileExtension = undefined;
+        if (inputFile != undefined) {
+            this.filepath = inputFile.filepath;
+            this.filename = inputFile.filename;
+            this.fileExtension = inputFile.fileExtension;
+        }
+        this.checklist = {};
+    }
+    clone() {
+        return JSON.parse(JSON.stringify(this));
+    }
+    /** return true if all checklist of the document if true */
+    checkAll() {
+        return this.checklist.every((item) => item == true);
+    }
+    /** Export document into a JSON file */
+    dump(path) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield promises_1.default.writeFile(path, JSON.stringify(Object.entries(this)));
+        });
+    }
+    /** Create a Document from a JSON file */
+    static load(path) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const file = promises_1.default.readFile(path);
+            const args = JSON.parse(file);
+            return new Document(Object.assign({ reconsctruted: true }, args));
+        });
+    }
+    /**
+     * Takes a list of Documents and return one Document where
+     * each field is set with the maximum probability field
+     * @param {Array<Document>} documents - A list of Documents
+     */
+    static mergePages(documents) {
+        var _a, _b;
+        const finalDocument = documents[0].clone();
+        const attributes = Object.getOwnPropertyNames(finalDocument);
+        for (const document of documents) {
+            for (const attribute of attributes) {
+                if (Array.isArray(document === null || document === void 0 ? void 0 : document[attribute])) {
+                    finalDocument[attribute] = ((_a = finalDocument[attribute]) === null || _a === void 0 ? void 0 : _a.length)
+                        ? finalDocument[attribute]
+                        : document === null || document === void 0 ? void 0 : document[attribute];
+                }
+                else if (((_b = document === null || document === void 0 ? void 0 : document[attribute]) === null || _b === void 0 ? void 0 : _b.probability) >
+                    finalDocument[attribute].probability) {
+                    finalDocument[attribute] = document === null || document === void 0 ? void 0 : document[attribute];
+                }
+            }
+        }
+        return finalDocument;
+    }
+}
+exports.Document = Document;

package/dist/documents/fields/amount.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Amount = void 0;
+const field_1 = require("@fields/field");
+class Amount extends field_1.Field {
+    /**
+     * @param {Object} prediction - Prediction object from HTTP response
+     * @param {String} valueKey - Key to use in the prediction dict
+     * @param {Boolean} reconstructed - Does the object is reconstructed (not extracted by the API)
+     * @param {Integer} pageNumber - Page number for multi pages pdf
+     */
+    constructor({ prediction, valueKey = "amount", reconstructed = false, pageNumber = 0, }) {
+        super({ prediction, valueKey, reconstructed, pageNumber });
+        this.value = +parseFloat(prediction[valueKey]).toFixed(3);
+        if (isNaN(this.value)) {
+            this.value = undefined;
+            this.probability = 0;
+        }
+    }
+}
+exports.Amount = Amount;

package/dist/documents/fields/date.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DateField = void 0;
+const field_1 = require("@fields/field");
+class DateField extends field_1.Field {
+    constructor({ prediction, valueKey = "iso", reconstructed = false, pageNumber = 0, }) {
+        super({ prediction, valueKey, reconstructed, pageNumber });
+        this.dateObject = new Date(this.value);
+        if (!(this.dateObject instanceof Date) ||
+            isNaN(this.dateObject.valueOf())) {
+            this.dateObject = undefined;
+            this.probability = 0.0;
+            this.value = undefined;
+        }
+    }
+}
+exports.DateField = DateField;

package/dist/documents/fields/field.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Field = void 0;
+class Field {
+    /**
+     * @param {Object} prediction - Prediction object from HTTP response
+     * @param {String} valueKey - Key to use in the prediction dict
+     * @param {Boolean} reconstructed - Does the object is reconstructed (not extracted by the API)
+     * @param {Integer} pageNumber - Page number for multi pages pdf
+     * @param {Array<String>} extraFields - Extra fields to get from the prediction and to set as attribute of the Field
+     */
+    constructor({ prediction, valueKey = "value", reconstructed = false, extraFields, pageNumber, }) {
+        this.pageNumber = pageNumber;
+        this.reconstructed = reconstructed;
+        this.value = undefined;
+        this.probability = prediction.confidence ? prediction.confidence : 0.0;
+        this.bbox = prediction.polygon ? prediction.polygon : [];
+        if (valueKey in prediction && prediction[valueKey] !== null) {
+            this.value = prediction[valueKey];
+            if (extraFields) {
+                for (const fieldName of extraFields) {
+                    this[fieldName] = prediction[fieldName];
+                }
+            }
+        }
+    }
+    compare(other) {
+        if (this.value == null && other.value == null)
+            return true;
+        else if (this.value == null || other.value == null)
+            return false;
+        else {
+            if (typeof this.value == "string") {
+                return this.value.toLowerCase() === other.value.toLowerCase();
+            }
+            else {
+                return this.value === other.value;
+            }
+        }
+    }
+    /**
+    @param {Array<Field>} array1 - first Array of Fields
+    @param {Array<Field>} array2 - second Array of Fields
+    @param {String} attr - Attribute to compare
+    @returns {Boolean} - true if all elements in array1 exist in array2 and vice-versa, false otherwise
+     */
+    static compareArrays(array1, array2, attr = "value") {
+        const list1 = array1.map((item) => item[attr]);
+        const list2 = array2.map((item) => item[attr]);
+        if (list1.length !== list2.length)
+            return false;
+        for (const item1 of list1) {
+            if (!list2.includes(item1))
+                return false;
+        }
+        return true;
+    }
+    /**
+     * @param {Array<Field>} array - Array of Fields
+     * @returns {Number} product of all the fields probaility
+     */
+    static arrayProbability(array) {
+        let total = 1.0;
+        for (const field of array) {
+            total *= field.probability;
+            if (isNaN(total))
+                return 0.0;
+        }
+        return total;
+    }
+    /**
+     * @param {Array<Field>} array - Array of Fields
+     * @returns {Number} Sum of all the Fields values in the array
+     */
+    static arraySum(array) {
+        let total = 0;
+        for (const field of array) {
+            total += field.value;
+            if (isNaN(total))
+                return 0.0;
+        }
+        return total;
+    }
+}
+exports.Field = Field;

package/dist/documents/fields/index.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Field = exports.DateField = exports.Amount = exports.Locale = exports.Orientation = exports.PaymentDetails = exports.Tax = void 0;
+var tax_1 = require("@fields/tax");
+Object.defineProperty(exports, "Tax", { enumerable: true, get: function () { return tax_1.Tax; } });
+var paymentDetails_1 = require("@fields/paymentDetails");
+Object.defineProperty(exports, "PaymentDetails", { enumerable: true, get: function () { return paymentDetails_1.PaymentDetails; } });
+var orientation_1 = require("@fields/orientation");
+Object.defineProperty(exports, "Orientation", { enumerable: true, get: function () { return orientation_1.Orientation; } });
+var locale_1 = require("@fields/locale");
+Object.defineProperty(exports, "Locale", { enumerable: true, get: function () { return locale_1.Locale; } });
+var amount_1 = require("@fields/amount");
+Object.defineProperty(exports, "Amount", { enumerable: true, get: function () { return amount_1.Amount; } });
+var date_1 = require("@fields/date");
+Object.defineProperty(exports, "DateField", { enumerable: true, get: function () { return date_1.DateField; } });
+var field_1 = require("@fields/field");
+Object.defineProperty(exports, "Field", { enumerable: true, get: function () { return field_1.Field; } });

package/dist/documents/fields/locale.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Locale = void 0;
+const field_1 = require("@fields/field");
+class Locale extends field_1.Field {
+    /**
+     * @param {Object} prediction - Prediction object from HTTP response
+     * @param {String} valueKey - Key to use in the prediction dict
+     * @param {Boolean} reconstructed - Does the object is reconstructed (not extracted by the API)
+     * @param {Integer} pageNumber - Page number for multi pages pdf
+     */
+    constructor({ prediction, valueKey = "value", reconstructed = false, pageNumber = 0, }) {
+        super({ prediction, valueKey, reconstructed, pageNumber });
+        this.language = undefined;
+        this.country = undefined;
+        this.currency = undefined;
+        if ("language" in prediction && prediction.language !== "N/A")
+            this.language = prediction.language;
+        if ("country" in prediction && prediction.country !== "N/A")
+            this.country = prediction.country;
+        if ("currency" in prediction && prediction.currency !== "N/A")
+            this.currency = prediction.currency;
+    }
+}
+exports.Locale = Locale;

package/dist/documents/fields/orientation.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Orientation = void 0;
+const field_1 = require("@fields/field");
+class Orientation extends field_1.Field {
+    /**
+     * @param {Object} prediction - Prediction object from HTTP response
+     * @param {String} valueKey - Key to use in the prediction dict
+     * @param {Boolean} reconstructed - Does the object is reconstructed (not extracted by the API)
+     * @param {Integer} pageNumber - Page number for multi pages pdf
+     */
+    constructor({ prediction, valueKey = "degrees", reconstructed = false, pageNumber = 0, }) {
+        const orientations = [0, 90, 180, 270];
+        super({ prediction, valueKey, reconstructed, pageNumber });
+        this.value = parseInt(prediction[valueKey]);
+        if (isNaN(this.value))
+            this.probability = 0.0;
+        if (!orientations.includes(this.value))
+            this.value = 0;
+    }
+}
+exports.Orientation = Orientation;

package/dist/documents/fields/paymentDetails.js

@@ -0,0 +1,50 @@
+"use strict";
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _PaymentDetails_instances, _PaymentDetails_setKey;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PaymentDetails = void 0;
+const field_1 = require("@fields/field");
+class PaymentDetails extends field_1.Field {
+    /**
+     * @param {Object} prediction - Prediction object from HTTP response
+     * @param {String} valueKey - Key to use in the prediction dict to get the iban
+     * @param {String} accountNumberKey - Key to use to get the account number in the prediction dict
+     * @param {String} ibanKey - Key to use to get the IBAN in the prediction dict
+     * @param {String} routingNumberKey - Key to use to get the routing number in the prediction dict
+     * @param {String} swiftKey - Key to use to get the SWIFT in the prediction dict
+     * @param {Boolean} reconstructed - Does the object is reconstructed (not extracted by the API)
+     * @param {Integer} pageNumber - Page number for multi pages pdf
+     */
+    constructor({ prediction, valueKey = "iban", accountNumberKey = "account_number", ibanKey = "iban", routingNumberKey = "routing_number", swiftKey = "swift", reconstructed = false, pageNumber = 0, }) {
+        super({ prediction, valueKey, reconstructed, pageNumber });
+        _PaymentDetails_instances.add(this);
+        this.accountNumber = undefined;
+        this.iban = undefined;
+        this.routingNumber = undefined;
+        this.swift = undefined;
+        __classPrivateFieldGet(this, _PaymentDetails_instances, "m", _PaymentDetails_setKey).call(this, prediction[accountNumberKey], "accountNumber");
+        __classPrivateFieldGet(this, _PaymentDetails_instances, "m", _PaymentDetails_setKey).call(this, prediction[ibanKey], "iban");
+        __classPrivateFieldGet(this, _PaymentDetails_instances, "m", _PaymentDetails_setKey).call(this, prediction[routingNumberKey], "routingNumber");
+        __classPrivateFieldGet(this, _PaymentDetails_instances, "m", _PaymentDetails_setKey).call(this, prediction[swiftKey], "swift");
+    }
+    toString() {
+        let str = "";
+        const keys = ["accountNumber", "iban", "routingNumber", "swift"];
+        for (const key of keys) {
+            if (this[key])
+                str += `${this[key]}; `;
+        }
+        return str;
+    }
+}
+exports.PaymentDetails = PaymentDetails;
+_PaymentDetails_instances = new WeakSet(), _PaymentDetails_setKey = function _PaymentDetails_setKey(value, key) {
+    if (typeof value === "string" && value !== "N/A")
+        this[key] = value;
+    else
+        this[key] = undefined;
+};

package/dist/documents/fields/tax.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Tax = void 0;
+const field_1 = require("@fields/field");
+class Tax extends field_1.Field {
+    /**
+     * @param {Object} prediction - Prediction object from HTTP response
+     * @param {String} valueKey - Key to use in the prediction dict to get the tax value
+     * @param {String} rateKey - Key to use to get the tax rate in the prediction dict
+     * @param {String} codeKey - Key to use to get the tax code in the prediction dict
+     * @param {Boolean} reconstructed - Does the object is reconstructed (not extracted by the API)
+     * @param {Integer} pageNumber - Page number for multi pages pdf
+     */
+    constructor({ prediction, valueKey = "value", rateKey = "rate", codeKey = "code", reconstructed = false, pageNumber = 0, }) {
+        var _a;
+        super({ prediction, valueKey, reconstructed, pageNumber });
+        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();
+        if (this.code === "N/A")
+            this.code = undefined;
+        this.value = parseFloat(prediction[valueKey]);
+        if (isNaN(this.value)) {
+            this.value = undefined;
+            this.probability = 0.0;
+        }
+    }
+    toString() {
+        let str = "";
+        const keys = ["value", "rate", "code"];
+        for (const [i, key] of keys.entries()) {
+            const value = this[key] === undefined ? "_" : this[key].toString();
+            if (i < keys.length - 1)
+                str += `${value}${key === "rate" ? "%" : ""}; `;
+            else
+                str += value;
+        }
+        return str;
+    }
+}
+exports.Tax = Tax;