mindee 1.4.0 → 2.0.0

package/dist/src/documents/receipt.js

@@ -0,0 +1,157 @@
+"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 _Receipt_instances, _Receipt_initFromApiPrediction, _Receipt_checklist, _Receipt_taxesMatchTotal, _Receipt_reconstruct, _Receipt_reconstructTotalExclFromTCCAndTaxes, _Receipt_reconstructTotalTax;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Receipt = void 0;
+const document_1 = require("./document");
+const fields_1 = require("../fields");
+class Receipt 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);
+        _Receipt_instances.add(this);
+        this.taxes = [];
+        this.locale = new fields_1.Locale({
+            prediction: apiPrediction.locale,
+            pageId: pageId,
+        });
+        this.totalTax = new fields_1.Amount({
+            prediction: { value: undefined, confidence: 0 },
+            valueKey: "value",
+            pageId: pageId,
+        });
+        this.totalExcl = new fields_1.Amount({
+            prediction: { value: undefined, confidence: 0 },
+            valueKey: "value",
+            pageId: pageId,
+        });
+        __classPrivateFieldGet(this, _Receipt_instances, "m", _Receipt_initFromApiPrediction).call(this, apiPrediction, pageId);
+        __classPrivateFieldGet(this, _Receipt_instances, "m", _Receipt_checklist).call(this);
+        __classPrivateFieldGet(this, _Receipt_instances, "m", _Receipt_reconstruct).call(this);
+    }
+    toString() {
+        const taxes = this.taxes.map((item) => item.toString()).join("\n       ");
+        const outStr = `-----Receipt data-----
+Filename: ${this.filename}
+Total amount including taxes: ${this.totalIncl}
+Total amount excluding taxes: ${this.totalExcl}
+Date: ${this.date}
+Category: ${this.category}
+Time: ${this.time}
+Merchant name: ${this.merchantName}
+Taxes: ${taxes}
+Total taxes: ${this.totalTax}
+Locale: ${this.locale}
+----------------------
+`;
+        return Receipt.cleanOutString(outStr);
+    }
+}
+exports.Receipt = Receipt;
+_Receipt_instances = new WeakSet(), _Receipt_initFromApiPrediction = function _Receipt_initFromApiPrediction(apiPrediction, pageId) {
+    this.totalIncl = new fields_1.Amount({
+        prediction: apiPrediction.total_incl,
+        valueKey: "value",
+        pageId: pageId,
+    });
+    this.date = new fields_1.DateField({
+        prediction: apiPrediction.date,
+        pageId: pageId,
+    });
+    this.category = new fields_1.Field({
+        prediction: apiPrediction.category,
+        pageId: pageId,
+    });
+    this.merchantName = new fields_1.Field({
+        prediction: apiPrediction.supplier,
+        pageId: pageId,
+    });
+    this.time = new fields_1.Field({
+        prediction: apiPrediction.time,
+        pageId: pageId,
+    });
+    apiPrediction.taxes.map((taxPrediction) => this.taxes.push(new fields_1.TaxField({
+        prediction: taxPrediction,
+        pageId: pageId,
+        valueKey: "value",
+        rateKey: "rate",
+        codeKey: "code",
+    })));
+    if (pageId !== undefined) {
+        this.orientation = new fields_1.Orientation({
+            prediction: apiPrediction.orientation,
+            pageId,
+        });
+    }
+}, _Receipt_checklist = function _Receipt_checklist() {
+    this.checklist = { taxesMatchTotalIncl: __classPrivateFieldGet(this, _Receipt_instances, "m", _Receipt_taxesMatchTotal).call(this) };
+}, _Receipt_taxesMatchTotal = function _Receipt_taxesMatchTotal() {
+    // Check taxes and total amount exist
+    if (this.taxes.length === 0 || this.totalIncl.value === undefined) {
+        return false;
+    }
+    // Reconstruct total_incl 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.forEach((tax) => {
+            tax.confidence = 1.0;
+        });
+        this.totalTax.confidence = 1.0;
+        this.totalIncl.confidence = 1.0;
+        return true;
+    }
+    return false;
+}, _Receipt_reconstruct = function _Receipt_reconstruct() {
+    __classPrivateFieldGet(this, _Receipt_instances, "m", _Receipt_reconstructTotalExclFromTCCAndTaxes).call(this);
+    __classPrivateFieldGet(this, _Receipt_instances, "m", _Receipt_reconstructTotalTax).call(this);
+}, _Receipt_reconstructTotalExclFromTCCAndTaxes = function _Receipt_reconstructTotalExclFromTCCAndTaxes() {
+    if (this.taxes.length && this.totalIncl.value !== undefined) {
+        const totalExcl = {
+            value: this.totalIncl.value - fields_1.Field.arraySum(this.taxes),
+            confidence: fields_1.Field.arrayConfidence(this.taxes) *
+                this.totalIncl.confidence,
+        };
+        this.totalExcl = new fields_1.Amount({
+            prediction: totalExcl,
+            valueKey: "value",
+            reconstructed: true,
+        });
+    }
+}, _Receipt_reconstructTotalTax = function _Receipt_reconstructTotalTax() {
+    if (this.taxes.length && this.totalTax.value === undefined) {
+        const totalTax = {
+            value: this.taxes
+                .map((tax) => tax.value || 0)
+                .reduce((a, b) => a + b, 0),
+            confidence: fields_1.Field.arrayConfidence(this.taxes),
+        };
+        if (totalTax.value > 0)
+            this.totalTax = new fields_1.Amount({
+                prediction: totalTax,
+                valueKey: "value",
+                reconstructed: true,
+            });
+    }
+};

package/dist/src/errors/handler.d.ts

@@ -0,0 +1,7 @@
+declare class ErrorHandler {
+    throwOnError: boolean;
+    constructor(throwOnError?: boolean);
+    throw(error: Error): void;
+}
+export declare const errorHandler: ErrorHandler;
+export {};

package/dist/src/errors/handler.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.errorHandler = void 0;
+const logger_1 = require("../logger");
+class ErrorHandler {
+    constructor(throwOnError = true) {
+        this.throwOnError = throwOnError;
+    }
+    throw(error) {
+        if (this.throwOnError) {
+            throw error;
+        }
+        else {
+            logger_1.logger.error(error.message);
+        }
+    }
+}
+exports.errorHandler = new ErrorHandler();

package/dist/src/fields/amount.d.ts

@@ -0,0 +1,13 @@
+import { Field, FieldConstructor } from "./field";
+export declare function floatToString(value: number): string;
+export declare class Amount extends Field {
+    value: number | undefined;
+    /**
+     * @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} pageId - Page ID for multi-page document
+     */
+    constructor({ prediction, valueKey, reconstructed, pageId, }: FieldConstructor);
+    toString(): string;
+}

package/dist/src/fields/amount.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Amount = exports.floatToString = void 0;
+const field_1 = require("./field");
+function floatToString(value) {
+    if (Number.isInteger(value)) {
+        return `${value}.0`;
+    }
+    return value.toString();
+}
+exports.floatToString = floatToString;
+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} pageId - Page ID for multi-page document
+     */
+    constructor({ prediction, valueKey = "amount", reconstructed = false, pageId = undefined, }) {
+        super({ prediction, valueKey, reconstructed, pageId });
+        this.value = +parseFloat(prediction[valueKey]).toFixed(3);
+        if (isNaN(this.value)) {
+            this.value = undefined;
+            this.confidence = 0.0;
+        }
+    }
+    toString() {
+        if (this.value !== undefined) {
+            return floatToString(this.value);
+        }
+        return "";
+    }
+}
+exports.Amount = Amount;

package/dist/src/fields/companyRegistration.d.ts

@@ -0,0 +1,6 @@
+import { Field, FieldConstructor } from "./field";
+export declare class CompanyRegistration extends Field {
+    /** Type of company registration number */
+    type: string;
+    constructor({ prediction, valueKey, reconstructed, pageId, }: FieldConstructor);
+}

package/dist/src/fields/companyRegistration.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CompanyRegistration = void 0;
+const field_1 = require("./field");
+class CompanyRegistration extends field_1.Field {
+    constructor({ prediction, valueKey = "value", reconstructed = false, pageId, }) {
+        super({ prediction, valueKey, reconstructed, pageId });
+        this.type = prediction.type;
+    }
+}
+exports.CompanyRegistration = CompanyRegistration;

package/dist/src/fields/customDocs.d.ts

@@ -0,0 +1,42 @@
+import { FieldConstructor, stringDict } from "./field";
+import { Polygon } from "../geometry";
+export declare class ClassificationField {
+    value: string;
+    confidence: number;
+    constructor({ prediction }: {
+        prediction: stringDict;
+    });
+    toString(): string;
+}
+export declare class ListFieldItem {
+    content: any;
+    /**
+     * The confidence score of the prediction.
+     * Note: Score is calculated on **word selection**, not its textual content (OCR).
+     */
+    confidence: number;
+    /**
+     * Contains exactly 4 relative vertices coordinates (points) of a right
+     * rectangle containing the word in the document.
+     */
+    bbox: Polygon;
+    /**
+     * Contains the relative vertices coordinates (points) of a polygon containing
+     * the word in the document.
+     */
+    polygon: Polygon;
+    constructor(prediction: stringDict);
+    toString(): string;
+}
+export declare class ListField {
+    values: ListFieldItem[];
+    confidence: number;
+    /** True if the field was reconstructed or computed using other fields. */
+    reconstructed: boolean;
+    /** The document page on which the information was found. */
+    pageId?: number;
+    constructor({ prediction, reconstructed, pageId }: FieldConstructor);
+    contentsList(): Array<any>;
+    contentsString(separator?: string): string;
+    toString(): string;
+}

package/dist/src/fields/customDocs.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ListField = exports.ListFieldItem = exports.ClassificationField = void 0;
+const geometry_1 = require("../geometry");
+class ClassificationField {
+    constructor({ prediction }) {
+        this.value = prediction["value"];
+        this.confidence = prediction["confidence"];
+    }
+    toString() {
+        return `${this.value}`;
+    }
+}
+exports.ClassificationField = ClassificationField;
+class ListFieldItem {
+    constructor(prediction) {
+        /**
+         * Contains exactly 4 relative vertices coordinates (points) of a right
+         * rectangle containing the word in the document.
+         */
+        this.bbox = [];
+        /**
+         * Contains the relative vertices coordinates (points) of a polygon containing
+         * the word in the document.
+         */
+        this.polygon = [];
+        this.content = prediction["content"];
+        this.confidence = prediction["confidence"];
+        if (prediction["polygon"]) {
+            this.polygon = prediction["polygon"];
+            this.bbox = (0, geometry_1.getBboxAsPolygon)(prediction.polygon);
+        }
+    }
+    toString() {
+        return `${this.content}`;
+    }
+}
+exports.ListFieldItem = ListFieldItem;
+class ListField {
+    constructor({ prediction, reconstructed = false, pageId }) {
+        this.values = [];
+        this.confidence = prediction["confidence"];
+        this.reconstructed = reconstructed;
+        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));
+            });
+        }
+    }
+    contentsList() {
+        return this.values.map((item) => item.content);
+    }
+    contentsString(separator = " ") {
+        return this.values.map((item) => `${item.content}`).join(separator);
+    }
+    toString() {
+        return this.contentsString();
+    }
+}
+exports.ListField = ListField;

package/dist/src/fields/date.d.ts

@@ -0,0 +1,12 @@
+import { Field, FieldConstructor } from "./field";
+export declare class DateField extends 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} pageId - Page ID for multi-page document
+     */
+    dateObject: Date | undefined;
+    constructor({ prediction, valueKey, reconstructed, pageId, }: FieldConstructor);
+    static compareDates(date1: Date, date2: Date): boolean;
+}

package/dist/src/fields/date.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DateField = void 0;
+const field_1 = require("./field");
+class DateField extends field_1.Field {
+    constructor({ prediction, valueKey = "value", reconstructed = false, pageId, }) {
+        super({ prediction, valueKey, reconstructed, pageId });
+        this.dateObject = new Date(this.value);
+        if (isNaN(this.dateObject.valueOf())) {
+            this.dateObject = undefined;
+            this.confidence = 0.0;
+            this.value = undefined;
+        }
+        else {
+            this.dateObject.setUTCHours(0, 0, 0, 0);
+        }
+    }
+    static compareDates(date1, date2) {
+        const check = date1.getFullYear() === date2.getFullYear() &&
+            date1.getMonth() === date2.getMonth() &&
+            date1.getDate() === date2.getDate();
+        return check;
+    }
+}
+exports.DateField = DateField;

package/dist/src/fields/field.d.ts

@@ -0,0 +1,74 @@
+import { Polygon } from "../geometry";
+export declare type stringDict = {
+    [index: string]: any;
+};
+export interface FieldConstructor {
+    prediction: {
+        [index: string]: any;
+    };
+    valueKey?: string;
+    reconstructed?: boolean;
+    pageId?: number | undefined;
+}
+interface BaseFieldConstructor {
+    prediction: stringDict;
+    valueKey: string;
+}
+export declare class BaseField {
+    value?: any;
+    /**
+     * @param {Object} prediction - Prediction object from HTTP response
+     * @param {String} valueKey - Key to use in the prediction dict
+     */
+    constructor({ prediction, valueKey }: BaseFieldConstructor);
+}
+export declare class Field extends BaseField {
+    /**
+     * Contains exactly 4 relative vertices coordinates (points) of a right
+     * rectangle containing the field in the document.
+     */
+    bbox: Polygon;
+    /**
+     * Contains the relative vertices coordinates (points) of a polygon containing
+     * the field in the document.
+     */
+    polygon: Polygon;
+    /** The document page on which the information was found. */
+    pageId: number | undefined;
+    /**
+     * The confidence score of the prediction.
+     */
+    confidence: number;
+    /**
+     * True if the field was reconstructed or computed using other fields.
+     */
+    reconstructed: boolean;
+    /**
+     * @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} pageId - Page ID for multi-page document
+     * @param {Array<String>} extraFields - Extra fields to get from the prediction and to set as attribute of the Field
+     */
+    constructor({ prediction, valueKey, reconstructed, pageId, }: FieldConstructor);
+    compare(other: Field): boolean;
+    /**
+    @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: Field[], array2: Field[], attr?: string): boolean;
+    /**
+     * @param {Array<Field>} array - Array of Fields
+     * @returns {Number} product of all the fields probaility
+     */
+    static arrayConfidence(array: any): number;
+    /**
+     * @param {Array<Field>} array - Array of Fields
+     * @returns {Number} Sum of all the Fields values in the array
+     */
+    static arraySum(array: any): number;
+    toString(): string;
+}
+export {};

package/dist/src/fields/field.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Field = exports.BaseField = void 0;
+const geometry_1 = require("../geometry");
+class BaseField {
+    /**
+     * @param {Object} prediction - Prediction object from HTTP response
+     * @param {String} valueKey - Key to use in the prediction dict
+     */
+    constructor({ prediction, valueKey }) {
+        this.value = undefined;
+        if (valueKey in prediction && prediction[valueKey] !== null) {
+            this.value = prediction[valueKey];
+        }
+    }
+}
+exports.BaseField = BaseField;
+class Field extends BaseField {
+    /**
+     * @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} pageId - Page ID for multi-page document
+     * @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, pageId, }) {
+        super({ prediction, valueKey });
+        /**
+         * Contains exactly 4 relative vertices coordinates (points) of a right
+         * rectangle containing the field in the document.
+         */
+        this.bbox = [];
+        /**
+         * Contains the relative vertices coordinates (points) of a polygon containing
+         * the field in the document.
+         */
+        this.polygon = [];
+        this.pageId = pageId !== undefined ? pageId : prediction["page_id"];
+        this.reconstructed = reconstructed;
+        this.confidence = prediction.confidence ? prediction.confidence : 0.0;
+        if (prediction.polygon) {
+            this.polygon = prediction.polygon;
+            this.bbox = (0, geometry_1.getBboxAsPolygon)(prediction.polygon);
+        }
+    }
+    compare(other) {
+        if (this.value === null && other.value === null)
+            return true;
+        if (this.value === null || other.value === null)
+            return false;
+        if (typeof this.value === "string") {
+            return this.value.toLowerCase() === other.value.toLowerCase();
+        }
+        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 arrayConfidence(array) {
+        let total = 1.0;
+        for (const field of array) {
+            total *= field.confidence;
+            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.0;
+        for (const field of array) {
+            total += field.value;
+            if (isNaN(total))
+                return 0.0;
+        }
+        return total;
+    }
+    toString() {
+        if (this.value !== undefined) {
+            return `${this.value}`;
+        }
+        return "";
+    }
+}
+exports.Field = Field;

package/dist/src/fields/fullText.d.ts

@@ -0,0 +1,24 @@
+import * as geometry from "../geometry";
+export declare type Word = {
+    /**
+     * Contains the relative vertices coordinates (points) of a polygon containing
+     * the field in the document.
+     */
+    polygon: geometry.Polygon;
+    text: string;
+    confidence: number;
+};
+declare type Line = Word[];
+export declare class FullText {
+    words: Word[];
+    /**
+     * Order all text on a page into lines.
+     * WARNING: This feature is experimental.
+     */
+    toLines(): Array<Line>;
+    /**
+     * WARNING: This feature is experimental.
+     */
+    toString(): string;
+}
+export {};