mindee 4.36.2 → 5.0.0-alpha1

package/src/v1/parsing/generated/generatedObject.d.ts

@@ -0,0 +1,35 @@
+import { StringDict } from "../../../parsing/stringDict.js";
+import { BaseFieldConstructor } from "../../../v1/parsing/standard/index.js";
+/** A JSON-like object, with miscellaneous values. */
+export declare class GeneratedObjectField {
+    /** The document page on which the information was found. */
+    pageId?: number;
+    /** Confidence with which the value was assessed. */
+    confidence?: number;
+    /** Raw unprocessed value, as it was sent by the server. */
+    rawValue?: string;
+    /** List of all printable field names. */
+    private printableValues;
+    /** All potentially present fields. */
+    [key: string]: string | number | boolean | object | undefined;
+    constructor({ prediction, pageId, }: BaseFieldConstructor);
+    /**
+     * ReSTructured-compliant string representation.
+     Takes into account level of indentation & displays elements as list elements.
+     * @param level Level of indentation. 0 by default.
+     */
+    toStringLevel(level?: number): string;
+    /**
+     * Formats a float number to have at least one decimal place.
+     * @param n Input number.
+     * @returns
+     */
+    private toNumberString;
+    toString(): string;
+    get(fieldName: string): string | number | boolean | object | undefined;
+}
+/**
+ * Checks whether a field is a custom object or not.
+ * @param strDict input dictionary to check.
+ */
+export declare function isGeneratedObject(strDict: StringDict): boolean;

package/src/v1/parsing/generated/generatedObject.js

@@ -0,0 +1,102 @@
+import { PositionField } from "../../../v1/parsing/standard/index.js";
+/** A JSON-like object, with miscellaneous values. */
+export class GeneratedObjectField {
+    constructor({ prediction = {}, pageId, }) {
+        let itemPageId = null;
+        this.printableValues = [];
+        for (const [fieldName, fieldValue] of Object.entries(prediction)) {
+            if (fieldName === "page_id") {
+                itemPageId = fieldValue;
+            }
+            else if (["polygon", "rectangle", "quadrangle", "bounding_box"].includes(fieldName)) {
+                Object.assign(this, {
+                    [fieldName]: new PositionField({
+                        prediction: { [fieldName]: fieldValue },
+                        valueKey: fieldName,
+                        pageId: pageId,
+                    }),
+                });
+                this.printableValues.push(fieldName);
+            }
+            else if (fieldName === "confidence") {
+                this.confidence = fieldValue;
+            }
+            else if (fieldName === "raw_value") {
+                this.rawValue = fieldValue;
+            }
+            else {
+                if (fieldValue !== null &&
+                    fieldValue !== undefined &&
+                    typeof fieldValue === "number" &&
+                    !isNaN(fieldValue) &&
+                    fieldName !== "degrees") {
+                    Object.assign(this, { [fieldName]: this.toNumberString(fieldValue) });
+                }
+                else if (typeof fieldValue === "boolean") {
+                    Object.assign(this, { [fieldName]: fieldValue });
+                }
+                else {
+                    Object.assign(this, {
+                        [fieldName]: (fieldValue !== undefined && fieldValue !== null) ?
+                            String(fieldValue) : null,
+                    });
+                }
+                this.printableValues.push(fieldName);
+            }
+            this.pageId = pageId ?? itemPageId;
+        }
+    }
+    /**
+     * ReSTructured-compliant string representation.
+     Takes into account level of indentation & displays elements as list elements.
+     * @param level Level of indentation. 0 by default.
+     */
+    toStringLevel(level = 0) {
+        const indent = "  " + "  ".repeat(level);
+        let outStr = "";
+        this.printableValues.forEach((printableValue) => {
+            const strValue = this[printableValue];
+            outStr += `\n${indent}:${printableValue}: ${strValue !== null && strValue !== undefined ? strValue : ""}`;
+        });
+        return `\n${indent}${outStr.trim()}`;
+    }
+    /**
+     * Formats a float number to have at least one decimal place.
+     * @param n Input number.
+     * @returns
+     */
+    toNumberString(n) {
+        if (Number.isInteger(n)) {
+            return n + ".0";
+        }
+        return n.toString();
+    }
+    toString() {
+        return this.toStringLevel();
+    }
+    get(fieldName) {
+        return this[fieldName];
+    }
+}
+/**
+ * Checks whether a field is a custom object or not.
+ * @param strDict input dictionary to check.
+ */
+export function isGeneratedObject(strDict) {
+    const commonKeys = [
+        "value",
+        "polygon",
+        "rectangle",
+        "page_id",
+        "confidence",
+        "quadrangle",
+        "values",
+        "raw_value",
+    ];
+    for (const key in strDict) {
+        if (Object.prototype.hasOwnProperty.call(strDict, key) && !commonKeys.includes(key)) {
+            return true;
+        }
+    }
+    return false;
+}

package/src/v1/parsing/generated/index.d.ts

@@ -0,0 +1,2 @@
+export { GeneratedObjectField, isGeneratedObject } from "./generatedObject.js";
+export { GeneratedListField } from "./generatedList.js";

package/src/v1/parsing/generated/index.js

@@ -0,0 +1,2 @@
+export { GeneratedObjectField, isGeneratedObject } from "./generatedObject.js";
+export { GeneratedListField } from "./generatedList.js";

package/src/v1/parsing/index.d.ts

@@ -0,0 +1,4 @@
+export * as common from "./common/index.js";
+export * as generated from "./generated/index.js";
+export * as standard from "./standard/index.js";
+export { LocalResponse } from "./localResponse.js";

package/src/v1/parsing/index.js

@@ -0,0 +1,4 @@
+export * as common from "./common/index.js";
+export * as generated from "./generated/index.js";
+export * as standard from "./standard/index.js";
+export { LocalResponse } from "./localResponse.js";

package/src/v1/parsing/localResponse.d.ts

@@ -0,0 +1,10 @@
+import { LocalResponseBase } from "../../parsing/localResponseBase.js";
+import { AsyncPredictResponse, Inference, PredictResponse } from "../../v1/index.js";
+import { StringDict } from "../../parsing/index.js";
+/**
+ * Local response loaded from a file.
+ * Note: Has to be initialized through init() before use.
+ */
+export declare class LocalResponse extends LocalResponseBase {
+    loadPrediction<T extends Inference>(productClass: new (httpResponse: StringDict) => T): Promise<AsyncPredictResponse<T> | PredictResponse<T>>;
+}

package/src/v1/parsing/localResponse.js

@@ -0,0 +1,29 @@
+import { LocalResponseBase } from "../../parsing/localResponseBase.js";
+import { AsyncPredictResponse, PredictResponse } from "../../v1/index.js";
+import { MindeeError } from "../../errors/index.js";
+/**
+ * Local response loaded from a file.
+ * Note: Has to be initialized through init() before use.
+ */
+export class LocalResponse extends LocalResponseBase {
+    async loadPrediction(productClass) {
+        /**
+         * Load a prediction.
+         *
+         * @param productClass Product class to use for calling the API and parsing the response.
+         * @param localResponse Local response to load.
+         * @category Asynchronous
+         * @returns A valid prediction
+         */
+        try {
+            const asDict = await this.asDict();
+            if (Object.prototype.hasOwnProperty.call(asDict, "job")) {
+                return new AsyncPredictResponse(productClass, asDict);
+            }
+            return new PredictResponse(productClass, asDict);
+        }
+        catch {
+            throw new MindeeError("No prediction found in local response.");
+        }
+    }
+}

package/src/v1/parsing/standard/addressField.d.ts

@@ -0,0 +1,25 @@
+import { StringField, FieldConstructor } from "./text.js";
+/**
+ * A field containing a detailed address value broken down into components
+ * (street number, city, postal code, …) while still exposing the full
+ * address string through {@link StringField.value}.
+ */
+export declare class AddressField extends StringField {
+    /** Street number. */
+    streetNumber?: string;
+    /** Street name. */
+    streetName?: string;
+    /** PO-box number. */
+    poBox?: string;
+    /** Additional address complement. */
+    addressComplement?: string;
+    /** City or locality. */
+    city?: string;
+    /** Postal / ZIP code. */
+    postalCode?: string;
+    /** State, province or region. */
+    state?: string;
+    /** Country. */
+    country?: string;
+    constructor({ prediction, valueKey, reconstructed, pageId, }: FieldConstructor);
+}

package/src/v1/parsing/standard/addressField.js

@@ -0,0 +1,36 @@
+import { StringField } from "./text.js";
+/**
+ * A field containing a detailed address value broken down into components
+ * (street number, city, postal code, …) while still exposing the full
+ * address string through {@link StringField.value}.
+ */
+export class AddressField extends StringField {
+    constructor({ prediction = {}, valueKey = "value", reconstructed = false, pageId, }) {
+        super({ prediction, valueKey, reconstructed, pageId });
+        // Populate the sub-components if they exist in the prediction object
+        if (prediction["street_number"]) {
+            this.streetNumber = prediction["street_number"];
+        }
+        if (prediction["street_name"]) {
+            this.streetName = prediction["street_name"];
+        }
+        if (prediction["po_box"]) {
+            this.poBox = prediction["po_box"];
+        }
+        if (prediction["address_complement"]) {
+            this.addressComplement = prediction["address_complement"];
+        }
+        if (prediction["city"]) {
+            this.city = prediction["city"];
+        }
+        if (prediction["postal_code"]) {
+            this.postalCode = prediction["postal_code"];
+        }
+        if (prediction["state"]) {
+            this.state = prediction["state"];
+        }
+        if (prediction["country"]) {
+            this.country = prediction["country"];
+        }
+    }
+}

package/src/v1/parsing/standard/amount.d.ts

@@ -0,0 +1,17 @@
+import { Field } from "./field.js";
+import { BaseFieldConstructor } from "./base.js";
+/**
+ * A field containing an amount value.
+ */
+export declare class AmountField extends Field {
+    /** The value. */
+    value?: number;
+    /**
+     * @param {BaseFieldConstructor} constructor Constructor parameters.
+     */
+    constructor({ prediction, valueKey, reconstructed, pageId, }: BaseFieldConstructor);
+    /**
+     * Default string representation.
+     */
+    toString(): string;
+}

package/src/v1/parsing/standard/amount.js

@@ -0,0 +1,29 @@
+import { Field } from "./field.js";
+import { floatToString } from "../../../v1/parsing/common/index.js";
+/**
+ * A field containing an amount value.
+ */
+export class AmountField extends Field {
+    /**
+     * @param {BaseFieldConstructor} constructor Constructor parameters.
+     */
+    constructor({ prediction = {}, valueKey = "value", reconstructed = false, pageId = undefined, }) {
+        super({ prediction, valueKey, reconstructed, pageId });
+        /** The value. */
+        this.value = undefined;
+        this.value = +parseFloat(prediction[valueKey]);
+        if (isNaN(this.value)) {
+            this.value = undefined;
+            this.confidence = 0.0;
+        }
+    }
+    /**
+     * Default string representation.
+     */
+    toString() {
+        if (this.value !== undefined) {
+            return floatToString(this.value);
+        }
+        return "";
+    }
+}

package/src/v1/parsing/standard/base.d.ts

@@ -0,0 +1,38 @@
+import { StringDict } from "../../../parsing/stringDict.js";
+/**
+ * @property {object} prediction - Prediction object from HTTP response.
+ * @property {string} valueKey - Key to use in the prediction dict.
+ * @property {boolean} reconstructed - Is the object reconstructed (not extracted by the API).
+ * @property {number} pageId - Page ID for multi-page document.
+ */
+export interface BaseFieldConstructor {
+    prediction: StringDict;
+    valueKey?: string;
+    reconstructed?: boolean;
+    pageId?: number;
+}
+/**
+ * Base class for most fields.
+ */
+export declare class BaseField {
+    /** The value. */
+    value?: string | number | boolean;
+    /** `true` when the field was reconstructed or computed using other fields. */
+    reconstructed: boolean;
+    /** Page ID for multi-page document. */
+    pageId?: number;
+    /**
+     * @param {BaseFieldConstructor} constructor Constructor parameters.
+     */
+    constructor({ prediction, valueKey, reconstructed, pageId, }: BaseFieldConstructor);
+    compare(other: BaseField): boolean;
+    /**
+     * @param {BaseField[]} array - Array of Fields
+     * @returns {number} Sum of all the Fields values in the array
+     */
+    static arraySum(array: BaseField[]): number;
+    /**
+     * Default string representation.
+     */
+    toString(): string;
+}

package/src/v1/parsing/standard/base.js

@@ -0,0 +1,54 @@
+/**
+ * Base class for most fields.
+ */
+export class BaseField {
+    /**
+     * @param {BaseFieldConstructor} constructor Constructor parameters.
+     */
+    constructor({ prediction = {}, valueKey = "value", reconstructed = false, pageId = undefined, }) {
+        /** The value. */
+        this.value = undefined;
+        this.reconstructed = reconstructed;
+        if (prediction !== undefined &&
+            prediction !== null &&
+            valueKey in prediction &&
+            prediction[valueKey] !== null) {
+            this.value = prediction[valueKey];
+            this.pageId = pageId !== undefined ? pageId : prediction["page_id"];
+        }
+    }
+    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" && typeof other.value === "string") {
+            return this.value.toLowerCase() === other.value.toLowerCase();
+        }
+        return this.value === other.value;
+    }
+    /**
+     * @param {BaseField[]} 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) {
+            if (typeof field.value !== "number")
+                return 0.0;
+            total += field.value;
+            if (isNaN(total))
+                return 0.0;
+        }
+        return total;
+    }
+    /**
+     * Default string representation.
+     */
+    toString() {
+        if (this.value !== undefined) {
+            return `${this.value}`;
+        }
+        return "";
+    }
+}

package/src/v1/parsing/standard/boolean.d.ts

@@ -0,0 +1,17 @@
+import { StringDict } from "../../../parsing/stringDict.js";
+import { Field } from "./field.js";
+export interface FieldConstructor {
+    prediction: StringDict;
+    valueKey?: string;
+    reconstructed?: boolean;
+    pageId?: number | undefined;
+}
+/**
+ * A field containing a text value.
+ */
+export declare class BooleanField extends Field {
+    /** The value. */
+    value?: boolean;
+    constructor({ prediction, valueKey, reconstructed, pageId, }: FieldConstructor);
+    toString(): string;
+}

package/src/v1/parsing/standard/boolean.js

@@ -0,0 +1,18 @@
+import { Field } from "./field.js";
+/**
+ * A field containing a text value.
+ */
+export class BooleanField extends Field {
+    constructor({ prediction = {}, valueKey = "value", reconstructed = false, pageId, }) {
+        super({ prediction, valueKey, reconstructed, pageId });
+    }
+    toString() {
+        if (this.value === true) {
+            return "True";
+        }
+        else if (this.value === false) {
+            return "False";
+        }
+        return "";
+    }
+}

package/src/v1/parsing/standard/classification.d.ts

@@ -0,0 +1,11 @@
+import { BaseField, BaseFieldConstructor } from "./base.js";
+/**
+ * Represents a classifier value.
+ */
+export declare class ClassificationField extends BaseField {
+    /** The confidence score of the prediction. */
+    confidence: number;
+    /** The classification. */
+    value?: string;
+    constructor({ prediction, valueKey, reconstructed, pageId, }: BaseFieldConstructor);
+}

package/src/v1/parsing/standard/classification.js

@@ -0,0 +1,10 @@
+import { BaseField } from "./base.js";
+/**
+ * Represents a classifier value.
+ */
+export class ClassificationField extends BaseField {
+    constructor({ prediction = {}, valueKey = "value", reconstructed = false, pageId = undefined, }) {
+        super({ prediction, valueKey, reconstructed, pageId });
+        this.confidence = prediction["confidence"] ? prediction["confidence"] : 0.0;
+    }
+}

package/src/v1/parsing/standard/companyRegistration.d.ts

@@ -0,0 +1,15 @@
+import { Field } from "./field.js";
+import { BaseFieldConstructor } from "./base.js";
+/**
+ * A company registration item.
+ */
+export declare class CompanyRegistrationField extends Field {
+    /** Registration identifier. */
+    value?: string;
+    /** Type of company registration. */
+    type: string;
+    constructor({ prediction, valueKey, reconstructed, pageId, }: BaseFieldConstructor);
+    toTableLine(): string;
+    toString(): string;
+    private printableValues;
+}

package/src/v1/parsing/standard/companyRegistration.js

@@ -0,0 +1,25 @@
+import { Field } from "./field.js";
+import { cleanOutString } from "../../../v1/parsing/common/index.js";
+/**
+ * A company registration item.
+ */
+export class CompanyRegistrationField extends Field {
+    constructor({ prediction = {}, valueKey = "value", reconstructed = false, pageId, }) {
+        super({ prediction, valueKey, reconstructed, pageId });
+        this.type = prediction["type"];
+    }
+    toTableLine() {
+        const printable = this.printableValues();
+        return `| ${printable["type"].padEnd(15)} | ${printable["value"].padEnd(20)} `;
+    }
+    toString() {
+        const printable = this.printableValues();
+        return `Type: ${printable["type"]}, Value: ${printable["value"]}`;
+    }
+    printableValues() {
+        const printable = {};
+        printable["type"] = cleanOutString(this.type);
+        printable["value"] = cleanOutString((this.value ?? "").toString());
+        return printable;
+    }
+}

package/src/v1/parsing/standard/date.d.ts

@@ -0,0 +1,18 @@
+import { Field } from "./field.js";
+import { BaseFieldConstructor } from "./base.js";
+/**
+ * A field containing a date value.
+ */
+export declare class DateField extends Field {
+    /** Date string in ISO format. */
+    value?: string;
+    /** Date as a standard JavaScript `Date` object. */
+    dateObject?: Date;
+    /** Whether the field was computed or retrieved directly from the document. */
+    isComputed?: boolean;
+    /**
+     * @param {BaseFieldConstructor} constructor Constructor parameters.
+     */
+    constructor({ prediction, valueKey, reconstructed, pageId, }: BaseFieldConstructor);
+    static compareDates(date1: Date, date2: Date): boolean;
+}

package/src/v1/parsing/standard/date.js

@@ -0,0 +1,31 @@
+import { Field } from "./field.js";
+/**
+ * A field containing a date value.
+ */
+export class DateField extends Field {
+    /**
+     * @param {BaseFieldConstructor} constructor Constructor parameters.
+     */
+    constructor({ prediction = {}, valueKey = "value", reconstructed = false, pageId, }) {
+        super({ prediction, valueKey, reconstructed, pageId });
+        if ("is_computed" in prediction) {
+            this.isComputed = prediction["is_computed"];
+        }
+        if (typeof this.value === "string") {
+            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) {
+        return date1.getFullYear() === date2.getFullYear() &&
+            date1.getMonth() === date2.getMonth() &&
+            date1.getDate() === date2.getDate();
+    }
+}

package/src/v1/parsing/standard/field.d.ts

@@ -0,0 +1,35 @@
+import { BaseField, BaseFieldConstructor } from "./base.js";
+import { Polygon, BoundingBox } from "../../../geometry/index.js";
+/**
+ * A basic field with position and page information.
+ */
+export declare class Field extends BaseField {
+    /**
+     * Contains exactly 4 relative vertices coordinates (points) of a right
+     * rectangle containing the field in the document.
+     */
+    boundingBox: BoundingBox;
+    /**
+     * Contains the relative vertices coordinates (points) of a polygon containing
+     * the field in the document.
+     */
+    polygon: Polygon;
+    /** The confidence score of the prediction. */
+    confidence: number;
+    /**
+     * @param {BaseFieldConstructor} constructor Constructor parameters.
+     */
+    constructor({ prediction, valueKey, reconstructed, pageId, }: BaseFieldConstructor);
+    /**
+    @param array1 first Array of Fields
+    @param array2 second Array of Fields
+    @param attr Attribute to compare
+    @returns true if all elements in array1 exist in array2 and vice-versa, false otherwise
+     */
+    static compareArrays(array1: Field[], array2: Field[], attr?: string): boolean;
+    /**
+     * @param {Field[]} array - Array of Fields
+     * @returns {number} product of all the fields probability
+     */
+    static arrayConfidence(array: Field[]): number;
+}

package/src/v1/parsing/standard/field.js

@@ -0,0 +1,53 @@
+import { BaseField } from "./base.js";
+import { Polygon, getBoundingBox } from "../../../geometry/index.js";
+/**
+ * A basic field with position and page information.
+ */
+export class Field extends BaseField {
+    /**
+     * @param {BaseFieldConstructor} constructor Constructor parameters.
+     */
+    constructor({ prediction = {}, valueKey = "value", reconstructed = false, pageId, }) {
+        super({ prediction, valueKey, reconstructed, pageId });
+        /**
+         * Contains the relative vertices coordinates (points) of a polygon containing
+         * the field in the document.
+         */
+        this.polygon = new Polygon();
+        this.confidence = prediction["confidence"] ? prediction["confidence"] : 0.0;
+        if (prediction["polygon"]) {
+            this.polygon = prediction["polygon"];
+        }
+        this.boundingBox = getBoundingBox(this.polygon);
+    }
+    /**
+    @param array1 first Array of Fields
+    @param array2 second Array of Fields
+    @param attr Attribute to compare
+    @returns 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 {Field[]} array - Array of Fields
+     * @returns {number} product of all the fields probability
+     */
+    static arrayConfidence(array) {
+        let total = 1.0;
+        for (const field of array) {
+            total *= field.confidence;
+            if (isNaN(total))
+                return 0.0;
+        }
+        return total;
+    }
+}

package/src/v1/parsing/standard/index.d.ts

@@ -0,0 +1,15 @@
+export { AddressField } from "./addressField.js";
+export { AmountField } from "./amount.js";
+export { BaseField } from "./base.js";
+export type { BaseFieldConstructor } from "./base.js";
+export { BooleanField } from "./boolean.js";
+export { ClassificationField } from "./classification.js";
+export { CompanyRegistrationField } from "./companyRegistration.js";
+export { DateField } from "./date.js";
+export { LocaleField } from "./locale.js";
+export { Field } from "./field.js";
+export { Taxes, TaxField } from "./tax.js";
+export { StringField } from "./text.js";
+export { PaymentDetailsField } from "./paymentDetails.js";
+export { PositionField } from "./position.js";
+export type { Word } from "./word.js";