mindee 1.4.0 → 2.0.0

package/dist/src/documents/documentConfig.d.ts

@@ -0,0 +1,44 @@
+import { Input } from "../inputs";
+import { Response, Endpoint } from "../api";
+import { Document } from "./index";
+import { ResponseProps } from "../api/response";
+interface CustomDocConstructor {
+    documentType: string;
+    accountName: string;
+    version: string;
+    apiKey: string;
+}
+export declare type responseSig<RespType extends Response<Document>> = {
+    new ({ httpResponse, documentType, input, error }: ResponseProps): RespType;
+};
+export declare class DocumentConfig {
+    readonly documentType: string;
+    readonly endpoints: Array<Endpoint>;
+    constructor(documentType: string, endpoints: Array<Endpoint>);
+    predictRequest(inputDoc: Input, includeWords?: boolean): Promise<unknown>;
+    buildResult<RespType extends Response<Document>>(responseType: responseSig<RespType>, inputFile: Input, response: any): RespType;
+    predict<RespType extends Response<Document>>(responseType: responseSig<RespType>, params: {
+        inputDoc: Input;
+        includeWords: boolean;
+        cutPages: boolean;
+    }): Promise<RespType>;
+    cutDocPages(inputDoc: Input, cutPages: boolean): Promise<void>;
+    protected checkApiKeys(): void;
+}
+export declare class InvoiceConfig extends DocumentConfig {
+    constructor(apiKey: string);
+}
+export declare class ReceiptConfig extends DocumentConfig {
+    constructor(apiKey: string);
+}
+export declare class FinancialDocConfig extends DocumentConfig {
+    constructor(apiKey: string);
+    predictRequest(inputDoc: Input, includeWords?: boolean): Promise<unknown>;
+}
+export declare class PassportConfig extends DocumentConfig {
+    constructor(apiKey: string);
+}
+export declare class CustomDocConfig extends DocumentConfig {
+    constructor({ documentType, accountName, version, apiKey, }: CustomDocConstructor);
+}
+export {};

package/dist/src/documents/documentConfig.js

@@ -0,0 +1,121 @@
+"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.CustomDocConfig = exports.PassportConfig = exports.FinancialDocConfig = exports.ReceiptConfig = exports.InvoiceConfig = exports.DocumentConfig = void 0;
+const api_1 = require("../api");
+const index_1 = require("./index");
+const handler_1 = require("../errors/handler");
+class DocumentConfig {
+    constructor(documentType, endpoints) {
+        this.documentType = documentType;
+        this.endpoints = endpoints;
+    }
+    predictRequest(inputDoc, includeWords = false) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.endpoints[0].predictRequest(inputDoc, includeWords);
+        });
+    }
+    buildResult(responseType, inputFile, response) {
+        if (response.statusCode > 201) {
+            const errorMessage = JSON.stringify(response.data, null, 4);
+            handler_1.errorHandler.throw(new Error(`${this.endpoints[0].urlName} API ${response.statusCode} HTTP error: ${errorMessage}`));
+            return new responseType({
+                httpResponse: response,
+                documentType: this.documentType,
+                input: inputFile,
+                error: true,
+            });
+        }
+        return new responseType({
+            httpResponse: response,
+            documentType: this.documentType,
+            input: inputFile,
+            error: false,
+        });
+    }
+    predict(responseType, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.checkApiKeys();
+            yield params.inputDoc.init();
+            yield this.cutDocPages(params.inputDoc, params.cutPages);
+            const response = yield this.predictRequest(params.inputDoc, params.includeWords);
+            return this.buildResult(responseType, params.inputDoc, response);
+        });
+    }
+    cutDocPages(inputDoc, cutPages) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (cutPages && inputDoc.isPdf()) {
+                yield inputDoc.cutPdf();
+            }
+        });
+    }
+    checkApiKeys() {
+        this.endpoints.forEach((endpoint) => {
+            if (!endpoint.apiKey) {
+                throw new Error(`Missing API key for '${endpoint.keyName}', check your Client configuration.
+You can set this using the '${api_1.API_KEY_ENVVAR_NAME}' environment variable.\n`);
+            }
+        });
+    }
+}
+exports.DocumentConfig = DocumentConfig;
+class InvoiceConfig extends DocumentConfig {
+    constructor(apiKey) {
+        const endpoints = [new api_1.InvoiceEndpoint(apiKey)];
+        super(index_1.DOC_TYPE_INVOICE, endpoints);
+    }
+}
+exports.InvoiceConfig = InvoiceConfig;
+class ReceiptConfig extends DocumentConfig {
+    constructor(apiKey) {
+        const endpoints = [new api_1.ReceiptEndpoint(apiKey)];
+        super(index_1.DOC_TYPE_RECEIPT, endpoints);
+    }
+}
+exports.ReceiptConfig = ReceiptConfig;
+class FinancialDocConfig extends DocumentConfig {
+    constructor(apiKey) {
+        const endpoints = [
+            new api_1.InvoiceEndpoint(apiKey),
+            new api_1.ReceiptEndpoint(apiKey),
+        ];
+        super(index_1.DOC_TYPE_FINANCIAL, endpoints);
+    }
+    predictRequest(inputDoc, includeWords = false) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let endpoint;
+            if (inputDoc.isPdf()) {
+                endpoint = this.endpoints[0];
+            }
+            else {
+                endpoint = this.endpoints[1];
+            }
+            return yield endpoint.predictRequest(inputDoc, includeWords);
+        });
+    }
+}
+exports.FinancialDocConfig = FinancialDocConfig;
+class PassportConfig extends DocumentConfig {
+    constructor(apiKey) {
+        const endpoints = [new api_1.PassportEndpoint(apiKey)];
+        super(index_1.DOC_TYPE_PASSPORT, endpoints);
+    }
+}
+exports.PassportConfig = PassportConfig;
+class CustomDocConfig extends DocumentConfig {
+    constructor({ documentType, accountName, version, apiKey, }) {
+        const endpoints = [
+            new api_1.CustomEndpoint(documentType, accountName, version, apiKey),
+        ];
+        super(documentType, endpoints);
+    }
+}
+exports.CustomDocConfig = CustomDocConfig;

package/dist/src/documents/financialDocument.d.ts

@@ -0,0 +1,32 @@
+import { Document, DocumentConstructorProps } from "./document";
+import { TaxField, Field, Amount, Locale, Orientation, DateField as Date, CompanyRegistration } from "../fields";
+export declare class FinancialDocument extends Document {
+    #private;
+    pageId: number | undefined;
+    locale: Locale;
+    totalIncl: Amount;
+    date: Date;
+    dueDate: Date;
+    category: Field;
+    time: Field;
+    orientation: Orientation | undefined;
+    taxes: TaxField[];
+    totalTax: Amount;
+    totalExcl: Amount;
+    supplier: Field;
+    supplierAddress: Field;
+    invoiceNumber: Field;
+    companyRegistration: CompanyRegistration[];
+    customerName: Field;
+    customerAddress: Field;
+    paymentDetails: Field[];
+    customerCompanyRegistration: CompanyRegistration[];
+    /**
+     * @param {Object} apiPrediction - Json parsed prediction from HTTP response
+     * @param {Input} inputFile - input file given to parse the document
+     * @param {number} pageId - Page ID for multi-page document
+     * @param {FullText} fullText - full OCR extracted text
+     */
+    constructor({ apiPrediction, inputFile, fullText, pageId, }: DocumentConstructorProps);
+    toString(): string;
+}

package/dist/src/documents/financialDocument.js

@@ -0,0 +1,130 @@
+"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 _FinancialDocument_instances, _FinancialDocument_initFromApiPrediction, _FinancialDocument_checklist, _FinancialDocument_taxesMatchTotalIncl;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FinancialDocument = void 0;
+const document_1 = require("./document");
+const invoice_1 = require("./invoice");
+const receipt_1 = require("./receipt");
+const fields_1 = require("../fields");
+class FinancialDocument extends document_1.Document {
+    /**
+     * @param {Object} apiPrediction - Json parsed prediction from HTTP response
+     * @param {Input} inputFile - input file given to parse the document
+     * @param {number} pageId - Page ID for multi-page document
+     * @param {FullText} fullText - full OCR extracted text
+     */
+    constructor({ apiPrediction, inputFile = undefined, fullText = undefined, pageId = undefined, }) {
+        super(inputFile, pageId, fullText);
+        _FinancialDocument_instances.add(this);
+        this.taxes = [];
+        this.companyRegistration = [];
+        this.paymentDetails = [];
+        this.customerCompanyRegistration = [];
+        __classPrivateFieldGet(this, _FinancialDocument_instances, "m", _FinancialDocument_initFromApiPrediction).call(this, apiPrediction, inputFile, pageId);
+        __classPrivateFieldGet(this, _FinancialDocument_instances, "m", _FinancialDocument_checklist).call(this);
+    }
+    toString() {
+        const outStr = `-----Financial document-----
+Filename: ${this.filename}
+Total amount: ${this.totalIncl.value}
+Date: ${this.date.value}
+Supplier: ${this.supplier.value}
+Total taxes: ${this.totalTax.value}
+----------------------
+`;
+        return FinancialDocument.cleanOutString(outStr);
+    }
+}
+exports.FinancialDocument = FinancialDocument;
+_FinancialDocument_instances = new WeakSet(), _FinancialDocument_initFromApiPrediction = function _FinancialDocument_initFromApiPrediction(prediction, inputFile, pageNumber) {
+    if (Object.keys(prediction).includes("invoice_number")) {
+        const invoice = new invoice_1.Invoice({
+            apiPrediction: prediction,
+            inputFile,
+            pageId: pageNumber,
+        });
+        this.locale = invoice.locale;
+        this.totalIncl = invoice.totalIncl;
+        this.totalExcl = invoice.totalExcl;
+        this.date = invoice.date;
+        this.invoiceNumber = invoice.invoiceNumber;
+        this.dueDate = invoice.dueDate;
+        this.taxes = invoice.taxes;
+        this.supplier = invoice.supplier;
+        this.supplierAddress = invoice.supplierAddress;
+        this.paymentDetails = invoice.paymentDetails;
+        this.companyRegistration = invoice.customerCompanyRegistration;
+        this.orientation = invoice.orientation;
+        this.totalTax = invoice.totalTax;
+        this.time = new fields_1.Field({
+            prediction: { value: undefined, confidence: 0.0 },
+        });
+        this.customerName = invoice.customerName;
+        this.customerAddress = invoice.customerAddress;
+        this.customerCompanyRegistration = invoice.customerCompanyRegistration;
+    }
+    else {
+        const receipt = new receipt_1.Receipt({
+            apiPrediction: prediction,
+            inputFile,
+            pageId: pageNumber,
+        });
+        this.orientation = receipt.orientation;
+        this.date = receipt.date;
+        this.dueDate = receipt.date;
+        this.taxes = receipt.taxes;
+        this.locale = receipt.locale;
+        this.totalIncl = receipt.totalIncl;
+        this.totalExcl = receipt.totalExcl;
+        this.supplier = receipt.merchantName;
+        this.supplierAddress = new fields_1.Field({
+            prediction: { value: undefined, confidence: 0.0 },
+        });
+        this.time = receipt.time;
+        this.totalTax = receipt.totalTax;
+        this.invoiceNumber = new fields_1.Field({
+            prediction: { value: undefined, confidence: 0.0 },
+        });
+        this.customerName = new fields_1.Field({
+            prediction: { value: undefined, confidence: 0.0 },
+        });
+        this.customerAddress = new fields_1.Field({
+            prediction: { value: undefined, confidence: 0.0 },
+        });
+    }
+}, _FinancialDocument_checklist = function _FinancialDocument_checklist() {
+    this.checklist = {
+        taxesMatchTotalIncl: __classPrivateFieldGet(this, _FinancialDocument_instances, "m", _FinancialDocument_taxesMatchTotalIncl).call(this),
+    };
+}, _FinancialDocument_taxesMatchTotalIncl = function _FinancialDocument_taxesMatchTotalIncl() {
+    // Check taxes and total include exist
+    if (this.taxes.length === 0 || this.totalIncl.value === undefined)
+        return false;
+    // Reconstruct totalIncl from taxes
+    let totalVat = 0;
+    let reconstructedTotal = 0;
+    this.taxes.forEach((tax) => {
+        if (tax.value === undefined || !tax.rate)
+            return false;
+        totalVat += tax.value;
+        reconstructedTotal += tax.value + (100 * tax.value) / tax.rate;
+    });
+    // Sanity check
+    if (totalVat <= 0)
+        return false;
+    // Crate epsilon
+    const eps = 1 / (100 * totalVat);
+    if (this.totalIncl.value * (1 - eps) - 0.02 <= reconstructedTotal &&
+        reconstructedTotal <= this.totalIncl.value * (1 + eps) + 0.02) {
+        this.taxes = this.taxes.map((tax) => (Object.assign(Object.assign({}, tax), { confidence: 1.0 })));
+        this.totalTax.confidence = 1.0;
+        this.totalIncl.confidence = 1.0;
+        return true;
+    }
+    return false;
+};

package/dist/src/documents/index.d.ts

@@ -0,0 +1,12 @@
+import { Invoice } from "./invoice";
+import { Receipt } from "./receipt";
+import { Passport } from "./passport";
+import { FinancialDocument } from "./financialDocument";
+import { CustomDocument } from "./custom";
+export { Document, DocumentConstructorProps } from "./document";
+export { Receipt, Invoice, FinancialDocument, Passport, CustomDocument };
+export declare const DOC_TYPE_INVOICE: string;
+export declare const DOC_TYPE_RECEIPT: string;
+export declare const DOC_TYPE_PASSPORT: string;
+export declare const DOC_TYPE_FINANCIAL: string;
+export declare const DOC_TYPE_CUSTOM: string;

package/dist/src/documents/index.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DOC_TYPE_CUSTOM = exports.DOC_TYPE_FINANCIAL = exports.DOC_TYPE_PASSPORT = exports.DOC_TYPE_RECEIPT = exports.DOC_TYPE_INVOICE = exports.CustomDocument = exports.Passport = exports.FinancialDocument = exports.Invoice = exports.Receipt = exports.Document = void 0;
+const invoice_1 = require("./invoice");
+Object.defineProperty(exports, "Invoice", { enumerable: true, get: function () { return invoice_1.Invoice; } });
+const receipt_1 = require("./receipt");
+Object.defineProperty(exports, "Receipt", { enumerable: true, get: function () { return receipt_1.Receipt; } });
+const passport_1 = require("./passport");
+Object.defineProperty(exports, "Passport", { enumerable: true, get: function () { return passport_1.Passport; } });
+const financialDocument_1 = require("./financialDocument");
+Object.defineProperty(exports, "FinancialDocument", { enumerable: true, get: function () { return financialDocument_1.FinancialDocument; } });
+const custom_1 = require("./custom");
+Object.defineProperty(exports, "CustomDocument", { enumerable: true, get: function () { return custom_1.CustomDocument; } });
+var document_1 = require("./document");
+Object.defineProperty(exports, "Document", { enumerable: true, get: function () { return document_1.Document; } });
+exports.DOC_TYPE_INVOICE = invoice_1.Invoice.name;
+exports.DOC_TYPE_RECEIPT = receipt_1.Receipt.name;
+exports.DOC_TYPE_PASSPORT = passport_1.Passport.name;
+exports.DOC_TYPE_FINANCIAL = financialDocument_1.FinancialDocument.name;
+exports.DOC_TYPE_CUSTOM = custom_1.CustomDocument.name;

package/dist/src/documents/invoice.d.ts

@@ -0,0 +1,37 @@
+import { Document, DocumentConstructorProps } from "./document";
+import { BaseField, TaxField, PaymentDetails, Orientation, Locale, Amount, Field, DateField, CompanyRegistration } from "../fields";
+export declare class Invoice extends Document {
+    #private;
+    locale: Locale;
+    documentType: BaseField;
+    totalIncl: Amount;
+    date: DateField;
+    dueDate: DateField;
+    time: Field;
+    orientation: Orientation;
+    totalTax: Amount;
+    totalExcl: Amount;
+    supplier: Field;
+    supplierAddress: Field;
+    invoiceNumber: Field;
+    companyRegistration: CompanyRegistration[];
+    customerName: Field;
+    customerAddress: Field;
+    taxes: TaxField[];
+    paymentDetails: PaymentDetails[];
+    customerCompanyRegistration: CompanyRegistration[];
+    /**
+     * @param {Object} apiPrediction - Json parsed prediction from HTTP response
+     * @param {Input} inputFile - input file given to parse the document
+     * @param {number} pageId - Page ID for multi-page document
+     * @param {FullText} fullText - full OCR extracted text
+     */
+    constructor({ apiPrediction, inputFile, fullText, pageId, }: DocumentConstructorProps);
+    toString(): string;
+    private taxesMatchTotalIncl;
+    /**
+     *
+     */
+    private taxesMatchTotalExcl;
+    private taxesAndTotalExclMatchTotalIncl;
+}